/*
 * A V4L2 driver for hm5065 cameras.
 *
 */
#include <linux/init.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/i2c.h>
#include <linux/delay.h>
#include <linux/videodev2.h>
#include <linux/clk.h>
#include <media/v4l2-device.h>
#include <media/v4l2-chip-ident.h>
#include <media/v4l2-mediabus.h>
#include <linux/io.h>
#include "camera.h"
#include "sensor_helper.h"

MODULE_AUTHOR("raymonxiu");
MODULE_DESCRIPTION("A low-level driver for hm5065 sensors");
MODULE_LICENSE("GPL");

#define AF_WIN_NEW_COORD
//for internel driver debug
#define DEV_DBG_EN      0
#if(DEV_DBG_EN == 1)
#define vfe_dev_dbg(x,arg...) printk("[HM5065]"x,##arg)
#else
#define vfe_dev_dbg(x,arg...)
#endif
#define vfe_dev_err(x,arg...) printk("[HM5065]"x,##arg)
#define vfe_dev_print(x,arg...) printk("[HM5065]"x,##arg)

#define LOG_ERR_RET(x)  { \
                          int ret;  \
                          ret = x; \
                          if(ret < 0) {\
                            vfe_dev_err("error at %s\n",__func__);  \
                            return ret; \
                          } \
                        }

//define module timing
#define MCLK              (24*1000*1000)
#define VREF_POL          V4L2_MBUS_VSYNC_ACTIVE_LOW
#define HREF_POL          V4L2_MBUS_HSYNC_ACTIVE_HIGH
#define CLK_POL           V4L2_MBUS_PCLK_SAMPLE_RISING
#define V4L2_IDENT_SENSOR 0x039E

#define SENSOR_NAME "hm5065"

#define CONTINUEOUS_AF
//#define AUTO_FPS
#define DENOISE_LV_AUTO
#define SHARPNESS 0x10

#ifdef AUTO_FPS
//#define AF_FAST
#endif

#ifndef DENOISE_LV_AUTO
#define DENOISE_LV 0x8
#endif

static bool single_af = false;

/*
 * Our nominal (default) frame rate.
 */
#define SENSOR_FRAME_RATE 30

/*
 * The hm5065 sits on i2c with ID 0x3e
 */
#define I2C_ADDR 0x3e

//static struct delayed_work sensor_s_ae_ratio_work;
static struct v4l2_subdev *glb_sd;

/*
 * Information we maintain about a known sensor.
 */
struct sensor_format_struct;  /* coming later */

struct cfg_array { /* coming later */
	struct regval_list * regs;
	int size;
};

static inline struct sensor_info *to_state(struct v4l2_subdev *sd)
{
  return container_of(sd, struct sensor_info, sd);
}


/*
 * The default register settings
 *
 */

static struct regval_list sensor_default_regs[] = {
	{0xFFFF,0x01},
	{0x9000,0x03},
	{0xA000,0x90},
	{0xA001,0x0C},
	{0xA002,0x56},
	{0xA003,0xE0},
	{0xA004,0xFE},
	{0xA005,0xA3},
	{0xA006,0xE0},
	{0xA007,0xFF},
	{0xA008,0x12},
	{0xA009,0x42},
	{0xA00A,0x85},
	{0xA00B,0x90},
	{0xA00C,0x01},
	{0xA00D,0xB7},
	{0xA00E,0xEE},
	{0xA00F,0xF0},
	{0xA010,0xFC},
	{0xA011,0xA3},
	{0xA012,0xEF},
	{0xA013,0xF0},
	{0xA014,0xFD},
	{0xA015,0x90},
	{0xA016,0x06},
	{0xA017,0x05},
	{0xA018,0xE0},
	{0xA019,0x75},
	{0xA01A,0xF0},
	{0xA01B,0x02},
	{0xA01C,0xA4},
	{0xA01D,0x2D},
	{0xA01E,0xFF},
	{0xA01F,0xE5},
	{0xA020,0xF0},
	{0xA021,0x3C},
	{0xA022,0xFE},
	{0xA023,0xAB},
	{0xA024,0x07},
	{0xA025,0xFA},
	{0xA026,0x33},
	{0xA027,0x95},
	{0xA028,0xE0},
	{0xA029,0xF9},
	{0xA02A,0xF8},
	{0xA02B,0x90},
	{0xA02C,0x0B},
	{0xA02D,0x4B},
	{0xA02E,0xE0},
	{0xA02F,0xFE},
	{0xA030,0xA3},
	{0xA031,0xE0},
	{0xA032,0xFF},
	{0xA033,0xEE},
	{0xA034,0x33},
	{0xA035,0x95},
	{0xA036,0xE0},
	{0xA037,0xFD},
	{0xA038,0xFC},
	{0xA039,0x12},
	{0xA03A,0x0C},
	{0xA03B,0x7B},
	{0xA03C,0x90},
	{0xA03D,0x01},
	{0xA03E,0xB9},
	{0xA03F,0x12},
	{0xA040,0x0E},
	{0xA041,0x05},
	{0xA042,0x90},
	{0xA043,0x01},
	{0xA044,0xB9},
	{0xA045,0xE0},
	{0xA046,0xFC},
	{0xA047,0xA3},
	{0xA048,0xE0},
	{0xA049,0xFD},
	{0xA04A,0xA3},
	{0xA04B,0xE0},
	{0xA04C,0xFE},
	{0xA04D,0xA3},
	{0xA04E,0xE0},
	{0xA04F,0xFF},
	{0xA050,0x78},
	{0xA051,0x08},
	{0xA052,0x12},
	{0xA053,0x0D},
	{0xA054,0xBF},
	{0xA055,0xA8},
	{0xA056,0x04},
	{0xA057,0xA9},
	{0xA058,0x05},
	{0xA059,0xAA},
	{0xA05A,0x06},
	{0xA05B,0xAB},
	{0xA05C,0x07},
	{0xA05D,0x90},
	{0xA05E,0x0B},
	{0xA05F,0x49},
	{0xA060,0xE0},
	{0xA061,0xFE},
	{0xA062,0xA3},
	{0xA063,0xE0},
	{0xA064,0xFF},
	{0xA065,0xEE},
	{0xA066,0x33},
	{0xA067,0x95},
	{0xA068,0xE0},
	{0xA069,0xFD},
	{0xA06A,0xFC},
	{0xA06B,0xC3},
	{0xA06C,0xEF},
	{0xA06D,0x9B},
	{0xA06E,0xFF},
	{0xA06F,0xEE},
	{0xA070,0x9A},
	{0xA071,0xFE},
	{0xA072,0xED},
	{0xA073,0x99},
	{0xA074,0xFD},
	{0xA075,0xEC},
	{0xA076,0x98},
	{0xA077,0xFC},
	{0xA078,0x78},
	{0xA079,0x01},
	{0xA07A,0x12},
	{0xA07B,0x0D},
	{0xA07C,0xBF},
	{0xA07D,0x90},
	{0xA07E,0x0C},
	{0xA07F,0x4A},
	{0xA080,0xE0},
	{0xA081,0xFC},
	{0xA082,0xA3},
	{0xA083,0xE0},
	{0xA084,0xF5},
	{0xA085,0x82},
	{0xA086,0x8C},
	{0xA087,0x83},
	{0xA088,0xC0},
	{0xA089,0x83},
	{0xA08A,0xC0},
	{0xA08B,0x82},
	{0xA08C,0x90},
	{0xA08D,0x0B},
	{0xA08E,0x48},
	{0xA08F,0xE0},
	{0xA090,0xD0},
	{0xA091,0x82},
	{0xA092,0xD0},
	{0xA093,0x83},
	{0xA094,0x75},
	{0xA095,0xF0},
	{0xA096,0x02},
	{0xA097,0x12},
	{0xA098,0x0E},
	{0xA099,0x45},
	{0xA09A,0xEE},
	{0xA09B,0xF0},
	{0xA09C,0xA3},
	{0xA09D,0xEF},
	{0xA09E,0xF0},
	{0xA09F,0x02},
	{0xA0A0,0xBA},
	{0xA0A1,0xD8},
	{0xA0A2,0x90},
	{0xA0A3,0x30},
	{0xA0A4,0x18},
	{0xA0A5,0xe4},
	{0xA0A6,0xf0},
	{0xA0A7,0x74},
	{0xA0A8,0x3f},
	{0xA0A9,0xf0},
	{0xA0AA,0x22},
	{0xA0BF,0x90},
	{0xA0C0,0x00},
	{0xA0C1,0x5E},
	{0xA0C2,0xE0},
	{0xA0C3,0xFF},
	{0xA0C4,0x70},
	{0xA0C5,0x20},
	{0xA0C6,0x90},
	{0xA0C7,0x47},
	{0xA0C8,0x04},
	{0xA0C9,0x74},
	{0xA0CA,0x0A},
	{0xA0CB,0xF0},
	{0xA0CC,0xA3},
	{0xA0CD,0x74},
	{0xA0CE,0x30},
	{0xA0CF,0xF0},
	{0xA0D0,0x90},
	{0xA0D1,0x47},
	{0xA0D2,0x0C},
	{0xA0D3,0x74},
	{0xA0D4,0x07},
	{0xA0D5,0xF0},
	{0xA0D6,0xA3},
	{0xA0D7,0x74},
	{0xA0D8,0xA8},
	{0xA0D9,0xF0},
	{0xA0DA,0x90},
	{0xA0DB,0x47},
	{0xA0DC,0xA4},
	{0xA0DD,0x74},
	{0xA0DE,0x01},
	{0xA0DF,0xF0},
	{0xA0E0,0x90},
	{0xA0E1,0x47},
	{0xA0E2,0xA8},
	{0xA0E3,0xF0},
	{0xA0E4,0x80},
	{0xA0E5,0x50},
	{0xA0E6,0xEF},
	{0xA0E7,0x64},
	{0xA0E8,0x01},
	{0xA0E9,0x60},
	{0xA0EA,0x04},
	{0xA0EB,0xEF},
	{0xA0EC,0xB4},
	{0xA0ED,0x03},
	{0xA0EE,0x20},
	{0xA0EF,0x90},
	{0xA0F0,0x47},
	{0xA0F1,0x04},
	{0xA0F2,0x74},
	{0xA0F3,0x05},
	{0xA0F4,0xF0},
	{0xA0F5,0xA3},
	{0xA0F6,0x74},
	{0xA0F7,0x18},
	{0xA0F8,0xF0},
	{0xA0F9,0x90},
	{0xA0FA,0x47},
	{0xA0FB,0x0C},
	{0xA0FC,0x74},
	{0xA0FD,0x03},
	{0xA0FE,0xF0},
	{0xA0FF,0xA3},
	{0xA100,0x74},
	{0xA101,0xD4},
	{0xA102,0xF0},
	{0xA103,0x90},
	{0xA104,0x47},
	{0xA105,0xA4},
	{0xA106,0x74},
	{0xA107,0x02},
	{0xA108,0xF0},
	{0xA109,0x90},
	{0xA10A,0x47},
	{0xA10B,0xA8},
	{0xA10C,0xF0},
	{0xA10D,0x80},
	{0xA10E,0x27},
	{0xA10F,0xEF},
	{0xA110,0x64},
	{0xA111,0x02},
	{0xA112,0x60},
	{0xA113,0x04},
	{0xA114,0xEF},
	{0xA115,0xB4},
	{0xA116,0x04},
	{0xA117,0x1E},
	{0xA118,0x90},
	{0xA119,0x47},
	{0xA11A,0x04},
	{0xA11B,0x74},
	{0xA11C,0x02},
	{0xA11D,0xF0},
	{0xA11E,0xA3},
	{0xA11F,0x74},
	{0xA120,0x8C},
	{0xA121,0xF0},
	{0xA122,0x90},
	{0xA123,0x47},
	{0xA124,0x0C},
	{0xA125,0x74},
	{0xA126,0x01},
	{0xA127,0xF0},
	{0xA128,0xA3},
	{0xA129,0x74},
	{0xA12A,0xEA},
	{0xA12B,0xF0},
	{0xA12C,0x90},
	{0xA12D,0x47},
	{0xA12E,0xA4},
	{0xA12F,0x74},
	{0xA130,0x04},
	{0xA131,0xF0},
	{0xA132,0x90},
	{0xA133,0x47},
	{0xA134,0xA8},
	{0xA135,0xF0},
	{0xA136,0x22},
	{0xA137,0x74},
	{0xA138,0x04},
	{0xA139,0xF0},
	{0xA13A,0xA3},
	{0xA13B,0x74},
	{0xA13C,0x20},
	{0xA13D,0xF0},
	{0xA13E,0xE4},
	{0xA13F,0xF5},
	{0xA140,0x22},
	{0xA141,0xE5},
	{0xA142,0x22},
	{0xA143,0xC3},
	{0xA144,0x94},
	{0xA145,0x40},
	{0xA146,0x40},
	{0xA147,0x03},
	{0xA148,0x02},
	{0xA149,0xF1},
	{0xA14A,0xFD},
	{0xA14B,0x90},
	{0xA14C,0x0A},
	{0xA14D,0xBA},
	{0xA14E,0xE0},
	{0xA14F,0xFE},
	{0xA150,0xA3},
	{0xA151,0xE0},
	{0xA152,0xFF},
	{0xA153,0xF5},
	{0xA154,0x82},
	{0xA155,0x8E},
	{0xA156,0x83},
	{0xA157,0xE0},
	{0xA158,0x54},
	{0xA159,0x70},
	{0xA15A,0xFD},
	{0xA15B,0xC4},
	{0xA15C,0x54},
	{0xA15D,0x0F},
	{0xA15E,0xFD},
	{0xA15F,0x90},
	{0xA160,0x0A},
	{0xA161,0xBC},
	{0xA162,0xE0},
	{0xA163,0xFA},
	{0xA164,0xA3},
	{0xA165,0xE0},
	{0xA166,0xF5},
	{0xA167,0x82},
	{0xA168,0x8A},
	{0xA169,0x83},
	{0xA16A,0xED},
	{0xA16B,0xF0},
	{0xA16C,0x90},
	{0xA16D,0x0A},
	{0xA16E,0xBD},
	{0xA16F,0xE0},
	{0xA170,0x04},
	{0xA171,0xF0},
	{0xA172,0x70},
	{0xA173,0x06},
	{0xA174,0x90},
	{0xA175,0x0A},
	{0xA176,0xBC},
	{0xA177,0xE0},
	{0xA178,0x04},
	{0xA179,0xF0},
	{0xA17A,0x8F},
	{0xA17B,0x82},
	{0xA17C,0x8E},
	{0xA17D,0x83},
	{0xA17E,0xA3},
	{0xA17F,0xE0},
	{0xA180,0xFF},
	{0xA181,0x90},
	{0xA182,0x0A},
	{0xA183,0xBC},
	{0xA184,0xE0},
	{0xA185,0xFC},
	{0xA186,0xA3},
	{0xA187,0xE0},
	{0xA188,0xF5},
	{0xA189,0x82},
	{0xA18A,0x8C},
	{0xA18B,0x83},
	{0xA18C,0xEF},
	{0xA18D,0xF0},
	{0xA18E,0x90},
	{0xA18F,0x0A},
	{0xA190,0xBD},
	{0xA191,0xE0},
	{0xA192,0x04},
	{0xA193,0xF0},
	{0xA194,0x70},
	{0xA195,0x06},
	{0xA196,0x90},
	{0xA197,0x0A},
	{0xA198,0xBC},
	{0xA199,0xE0},
	{0xA19A,0x04},
	{0xA19B,0xF0},
	{0xA19C,0x90},
	{0xA19D,0x0A},
	{0xA19E,0xBA},
	{0xA19F,0xE0},
	{0xA1A0,0xFE},
	{0xA1A1,0xA3},
	{0xA1A2,0xE0},
	{0xA1A3,0xFF},
	{0xA1A4,0xF5},
	{0xA1A5,0x82},
	{0xA1A6,0x8E},
	{0xA1A7,0x83},
	{0xA1A8,0xE0},
	{0xA1A9,0x54},
	{0xA1AA,0x07},
	{0xA1AB,0xFD},
	{0xA1AC,0x90},
	{0xA1AD,0x0A},
	{0xA1AE,0xBC},
	{0xA1AF,0xE0},
	{0xA1B0,0xFA},
	{0xA1B1,0xA3},
	{0xA1B2,0xE0},
	{0xA1B3,0xF5},
	{0xA1B4,0x82},
	{0xA1B5,0x8A},
	{0xA1B6,0x83},
	{0xA1B7,0xED},
	{0xA1B8,0xF0},
	{0xA1B9,0x90},
	{0xA1BA,0x0A},
	{0xA1BB,0xBD},
	{0xA1BC,0xE0},
	{0xA1BD,0x04},
	{0xA1BE,0xF0},
	{0xA1BF,0x70},
	{0xA1C0,0x06},
	{0xA1C1,0x90},
	{0xA1C2,0x0A},
	{0xA1C3,0xBC},
	{0xA1C4,0xE0},
	{0xA1C5,0x04},
	{0xA1C6,0xF0},
	{0xA1C7,0x8F},
	{0xA1C8,0x82},
	{0xA1C9,0x8E},
	{0xA1CA,0x83},
	{0xA1CB,0xA3},
	{0xA1CC,0xA3},
	{0xA1CD,0xE0},
	{0xA1CE,0xFF},
	{0xA1CF,0x90},
	{0xA1D0,0x0A},
	{0xA1D1,0xBC},
	{0xA1D2,0xE0},
	{0xA1D3,0xFC},
	{0xA1D4,0xA3},
	{0xA1D5,0xE0},
	{0xA1D6,0xF5},
	{0xA1D7,0x82},
	{0xA1D8,0x8C},
	{0xA1D9,0x83},
	{0xA1DA,0xEF},
	{0xA1DB,0xF0},
	{0xA1DC,0x90},
	{0xA1DD,0x0A},
	{0xA1DE,0xBD},
	{0xA1DF,0xE0},
	{0xA1E0,0x04},
	{0xA1E1,0xF0},
	{0xA1E2,0x70},
	{0xA1E3,0x06},
	{0xA1E4,0x90},
	{0xA1E5,0x0A},
	{0xA1E6,0xBC},
	{0xA1E7,0xE0},
	{0xA1E8,0x04},
	{0xA1E9,0xF0},
	{0xA1EA,0x90},
	{0xA1EB,0x0A},
	{0xA1EC,0xBB},
	{0xA1ED,0xE0},
	{0xA1EE,0x24},
	{0xA1EF,0x03},
	{0xA1F0,0xF0},
	{0xA1F1,0x90},
	{0xA1F2,0x0A},
	{0xA1F3,0xBA},
	{0xA1F4,0xE0},
	{0xA1F5,0x34},
	{0xA1F6,0x00},
	{0xA1F7,0xF0},
	{0xA1F8,0x05},
	{0xA1F9,0x22},
	{0xA1FA,0x02},
	{0xA1FB,0xF1},
	{0xA1FC,0x41},
	{0xA1FD,0x90},
	{0xA1FE,0x0A},
	{0xA1FF,0xBA},
	{0xA200,0x74},
	{0xA201,0x0E},
	{0xA202,0xF0},
	{0xA203,0xA3},
	{0xA204,0x74},
	{0xA205,0xDC},
	{0xA206,0xF0},
	{0xA207,0xA3},
	{0xA208,0x74},
	{0xA209,0x05},
	{0xA20A,0xF0},
	{0xA20B,0xA3},
	{0xA20C,0x74},
	{0xA20D,0x61},
	{0xA20E,0xF0},
	{0xA20F,0x90},
	{0xA210,0x0A},
	{0xA211,0xBA},
	{0xA212,0xE0},
	{0xA213,0xFE},
	{0xA214,0xA3},
	{0xA215,0xE0},
	{0xA216,0xAA},
	{0xA217,0x06},
	{0xA218,0xF9},
	{0xA219,0x7B},
	{0xA21A,0x01},
	{0xA21B,0xC0},
	{0xA21C,0x02},
	{0xA21D,0xA3},
	{0xA21E,0xE0},
	{0xA21F,0xFE},
	{0xA220,0xA3},
	{0xA221,0xE0},
	{0xA222,0xAA},
	{0xA223,0x06},
	{0xA224,0xF8},
	{0xA225,0xAC},
	{0xA226,0x02},
	{0xA227,0x7D},
	{0xA228,0x01},
	{0xA229,0xD0},
	{0xA22A,0x02},
	{0xA22B,0x7E},
	{0xA22C,0x00},
	{0xA22D,0x7F},
	{0xA22E,0x04},
	{0xA22F,0x12},
	{0xA230,0x0F},
	{0xA231,0x6F},
	{0xA232,0x02},
	{0xA233,0x66},
	{0xA234,0xD9},
	{0xA235,0x90},
	{0xA236,0x07},
	{0xA237,0xD0},
	{0xA238,0x02},
	{0xA239,0xA2},
	{0xA23A,0x69},
	{0xA240,0x02},
	{0xA241,0x21},
	{0xA242,0x7F},
	{0xA243,0x02},
	{0xA244,0x21},
	{0xA245,0xF4},
	{0xA246,0x02},
	{0xA247,0xA6},
	{0xA248,0x15},
	{0xA249,0x60},
	{0xA24A,0x0A},
	{0xA24B,0xEF},
	{0xA24C,0xB4},
	{0xA24D,0x01},
	{0xA24E,0x16},
	{0xA24F,0x90},
	{0xA250,0x00},
	{0xA251,0x5D},
	{0xA252,0xE0},
	{0xA253,0x70},
	{0xA254,0x10},
	{0xA255,0x12},
	{0xA256,0x26},
	{0xA257,0xC8},
	{0xA258,0x90},
	{0xA259,0x00},
	{0xA25A,0x11},
	{0xA25B,0x74},
	{0xA25C,0x30},
	{0xA25D,0xF0},
	{0xA25E,0x90},
	{0xA25F,0x00},
	{0xA260,0x10},
	{0xA261,0x74},
	{0xA262,0x01},
	{0xA263,0xF0},
	{0xA264,0x22},
	{0xA265,0x12},
	{0xA266,0x25},
	{0xA267,0xA8},
	{0xA268,0x02},
	{0xA269,0x29},
	{0xA26A,0xFC},
	{0xA26B,0x44},
	{0xA26C,0x18},
	{0xA26D,0xF0},
	{0xA26E,0x90},
	{0xA26F,0x72},
	{0xA270,0x18},
	{0xA271,0xE0},
	{0xA272,0x44},
	{0xA273,0x18},
	{0xA274,0xF0},
	{0xA275,0x00},
	{0xA276,0x00},
	{0xA277,0x00},
	{0xA278,0x00},
	{0xA279,0x00},
	{0xA27A,0x00},
	{0xA27B,0x90},
	{0xA27C,0x72},
	{0xA27D,0x08},
	{0xA27E,0xE0},
	{0xA27F,0x44},
	{0xA280,0x10},
	{0xA281,0xF0},
	{0xA282,0x90},
	{0xA283,0x72},
	{0xA284,0x14},
	{0xA285,0xE0},
	{0xA286,0x54},
	{0xA287,0xFD},
	{0xA288,0xF0},
	{0xA289,0x22},
	{0xA29B,0xF0},
	{0xA29C,0xD3},
	{0xA29D,0x90},
	{0xA29E,0x07},
	{0xA29F,0x91},
	{0xA2A0,0xE0},
	{0xA2A1,0x94},
	{0xA2A2,0x21},
	{0xA2A3,0x90},
	{0xA2A4,0x07},
	{0xA2A5,0x90},
	{0xA2A6,0xE0},
	{0xA2A7,0x64},
	{0xA2A8,0x80},
	{0xA2A9,0x94},
	{0xA2AA,0x81},
	{0xA2AB,0x40},
	{0xA2AC,0x08},
	{0xA2AD,0x90},
	{0xA2AE,0x07},
	{0xA2AF,0xCB},
	{0xA2B0,0x74},
	{0xA2B1,0xFF},
	{0xA2B2,0xF0},
	{0xA2B3,0x80},
	{0xA2B4,0x06},
	{0xA2B5,0x90},
	{0xA2B6,0x07},
	{0xA2B7,0xCB},
	{0xA2B8,0x74},
	{0xA2B9,0x01},
	{0xA2BA,0xF0},
	{0xA2BB,0x02},
	{0xA2BC,0xB5},
	{0xA2BD,0xC3},
	{0xA2BE,0x90},
	{0xA2BF,0x08},
	{0xA2C0,0x34},
	{0xA2C1,0xE0},
	{0xA2C2,0xFC},
	{0xA2C3,0xA3},
	{0xA2C4,0xE0},
	{0xA2C5,0xFD},
	{0xA2C6,0xA3},
	{0xA2C7,0xE0},
	{0xA2C8,0xFE},
	{0xA2C9,0xA3},
	{0xA2CA,0xE0},
	{0xA2CB,0xFF},
	{0xA2CC,0x90},
	{0xA2CD,0x07},
	{0xA2CE,0xD0},
	{0xA2CF,0xE0},
	{0xA2D0,0xF8},
	{0xA2D1,0xA3},
	{0xA2D2,0xE0},
	{0xA2D3,0xF9},
	{0xA2D4,0xA3},
	{0xA2D5,0xE0},
	{0xA2D6,0xFA},
	{0xA2D7,0xA3},
	{0xA2D8,0xE0},
	{0xA2D9,0xFB},
	{0xA2DA,0xD3},
	{0xA2DB,0x12},
	{0xA2DC,0x0D},
	{0xA2DD,0xAE},
	{0xA2DE,0x40},
	{0xA2DF,0x0B},
	{0xA2E0,0x12},
	{0xA2E1,0xB5},
	{0xA2E2,0x49},
	{0xA2E3,0x90},
	{0xA2E4,0x07},
	{0xA2E5,0xA4},
	{0xA2E6,0x74},
	{0xA2E7,0x02},
	{0xA2E8,0xF0},
	{0xA2E9,0x80},
	{0xA2EA,0x09},
	{0xA2EB,0x12},
	{0xA2EC,0xB7},
	{0xA2ED,0x51},
	{0xA2EE,0x90},
	{0xA2EF,0x07},
	{0xA2F0,0xA4},
	{0xA2F1,0x74},
	{0xA2F2,0x05},
	{0xA2F3,0xF0},
	{0xA2F4,0x02},
	{0xA2F5,0xA2},
	{0xA2F6,0xDA},
	{0xA2F7,0x90},
	{0xA2F8,0x0E},
	{0xA2F9,0xE0},
	{0xA2FA,0xE0},
	{0xA2FB,0xFD},
	{0xA2FC,0xA3},
	{0xA2FD,0xE0},
	{0xA2FE,0x90},
	{0xA2FF,0x02},
	{0xA300,0xA2},
	{0xA301,0xCD},
	{0xA302,0xF0},
	{0xA303,0xA3},
	{0xA304,0xED},
	{0xA305,0xF0},
	{0xA306,0x90},
	{0xA307,0x0E},
	{0xA308,0xE2},
	{0xA309,0xE0},
	{0xA30A,0xFD},
	{0xA30B,0xA3},
	{0xA30C,0xE0},
	{0xA30D,0x90},
	{0xA30E,0x02},
	{0xA30F,0xA8},
	{0xA310,0xCD},
	{0xA311,0xF0},
	{0xA312,0xA3},
	{0xA313,0xED},
	{0xA314,0xF0},
	{0xA315,0xE4},
	{0xA316,0x90},
	{0xA317,0x06},
	{0xA318,0x38},
	{0xA319,0xF0},
	{0xA31A,0x02},
	{0xA31B,0x67},
	{0xA31C,0x63},
	{0xA31D,0x90},
	{0xA31E,0x0E},
	{0xA31F,0xE8},
	{0xA320,0xE0},
	{0xA321,0x90},
	{0xA322,0x02},
	{0xA323,0x62},
	{0xA324,0xF0},
	{0xA325,0x90},
	{0xA326,0x0E},
	{0xA327,0xE9},
	{0xA328,0xE0},
	{0xA329,0x90},
	{0xA32A,0x02},
	{0xA32B,0x63},
	{0xA32C,0xF0},
	{0xA32D,0x02},
	{0xA32E,0x67},
	{0xA32F,0x1F},
	{0xA33B,0x90},
	{0xA33C,0x0E},
	{0xA33D,0x14},
	{0xA33E,0xE0},
	{0xA33F,0xFE},
	{0xA340,0xA3},
	{0xA341,0xE0},
	{0xA342,0xFF},
	{0xA343,0x90},
	{0xA344,0x06},
	{0xA345,0xD9},
	{0xA346,0xEE},
	{0xA347,0xF0},
	{0xA348,0xA3},
	{0xA349,0xEF},
	{0xA34A,0xF0},
	{0xA34B,0x90},
	{0xA34C,0x0E},
	{0xA34D,0x18},
	{0xA34E,0xE0},
	{0xA34F,0xFD},
	{0xA350,0x7C},
	{0xA351,0x00},
	{0xA352,0xC3},
	{0xA353,0xEF},
	{0xA354,0x9D},
	{0xA355,0xEE},
	{0xA356,0x9C},
	{0xA357,0x50},
	{0xA358,0x09},
	{0xA359,0xE4},
	{0xA35A,0x90},
	{0xA35B,0x06},
	{0xA35C,0xD7},
	{0xA35D,0xF0},
	{0xA35E,0xA3},
	{0xA35F,0xF0},
	{0xA360,0x80},
	{0xA361,0x13},
	{0xA362,0xC3},
	{0xA363,0x90},
	{0xA364,0x06},
	{0xA365,0xDA},
	{0xA366,0xE0},
	{0xA367,0x9D},
	{0xA368,0xFE},
	{0xA369,0x90},
	{0xA36A,0x06},
	{0xA36B,0xD9},
	{0xA36C,0xE0},
	{0xA36D,0x9C},
	{0xA36E,0x90},
	{0xA36F,0x06},
	{0xA370,0xD7},
	{0xA371,0xF0},
	{0xA372,0xA3},
	{0xA373,0xCE},
	{0xA374,0xF0},
	{0xA375,0x90},
	{0xA376,0x0E},
	{0xA377,0x18},
	{0xA378,0xE0},
	{0xA379,0xF9},
	{0xA37A,0xFF},
	{0xA37B,0x90},
	{0xA37C,0x06},
	{0xA37D,0xC2},
	{0xA37E,0xE0},
	{0xA37F,0xFC},
	{0xA380,0xA3},
	{0xA381,0xE0},
	{0xA382,0xFD},
	{0xA383,0xC3},
	{0xA384,0x9F},
	{0xA385,0xFF},
	{0xA386,0xEC},
	{0xA387,0x94},
	{0xA388,0x00},
	{0xA389,0xFE},
	{0xA38A,0x90},
	{0xA38B,0x0E},
	{0xA38C,0x16},
	{0xA38D,0xE0},
	{0xA38E,0xFA},
	{0xA38F,0xA3},
	{0xA390,0xE0},
	{0xA391,0xFB},
	{0xA392,0xD3},
	{0xA393,0x9F},
	{0xA394,0xEA},
	{0xA395,0x9E},
	{0xA396,0x40},
	{0xA397,0x0A},
	{0xA398,0x90},
	{0xA399,0x06},
	{0xA39A,0xD5},
	{0xA39B,0xEC},
	{0xA39C,0xF0},
	{0xA39D,0xA3},
	{0xA39E,0xED},
	{0xA39F,0xF0},
	{0xA3A0,0x80},
	{0xA3A1,0x0E},
	{0xA3A2,0xE9},
	{0xA3A3,0x7E},
	{0xA3A4,0x00},
	{0xA3A5,0x2B},
	{0xA3A6,0xFF},
	{0xA3A7,0xEE},
	{0xA3A8,0x3A},
	{0xA3A9,0x90},
	{0xA3AA,0x06},
	{0xA3AB,0xD5},
	{0xA3AC,0xF0},
	{0xA3AD,0xA3},
	{0xA3AE,0xEF},
	{0xA3AF,0xF0},
	{0xA3B0,0xE9},
	{0xA3B1,0xFB},
	{0xA3B2,0x7A},
	{0xA3B3,0x00},
	{0xA3B4,0x90},
	{0xA3B5,0x0E},
	{0xA3B6,0x15},
	{0xA3B7,0xE0},
	{0xA3B8,0x2B},
	{0xA3B9,0xFE},
	{0xA3BA,0x90},
	{0xA3BB,0x0E},
	{0xA3BC,0x14},
	{0xA3BD,0xE0},
	{0xA3BE,0x3A},
	{0xA3BF,0x90},
	{0xA3C0,0x06},
	{0xA3C1,0xE1},
	{0xA3C2,0xF0},
	{0xA3C3,0xA3},
	{0xA3C4,0xCE},
	{0xA3C5,0xF0},
	{0xA3C6,0xC3},
	{0xA3C7,0x90},
	{0xA3C8,0x0E},
	{0xA3C9,0x17},
	{0xA3CA,0xE0},
	{0xA3CB,0x9B},
	{0xA3CC,0xFE},
	{0xA3CD,0x90},
	{0xA3CE,0x0E},
	{0xA3CF,0x16},
	{0xA3D0,0x02},
	{0xA3D1,0x20},
	{0xA3D2,0xD5},
	{0xA3D3,0x90},
	{0xA3d4,0x0E},
	{0xA3d5,0xE4},
	{0xA3d6,0xE0},
	{0xA3d7,0x90},
	{0xA3d8,0x02},
	{0xA3d9,0x66},
	{0xA3da,0xF0},
	{0xA3DB,0x90},
	{0xA3dc,0x0E},
	{0xA3dd,0xE5},
	{0xA3de,0xE0},
	{0xA3df,0x90},
	{0xA3e0,0x02},
	{0xA3e1,0x64},
	{0xA3e2,0xF0},
	{0xA3e3,0x90},
	{0xA3e4,0x0E},
	{0xA3e5,0xE6},
	{0xA3e6,0xE0},
	{0xA3e7,0x90},
	{0xA3e8,0x02},
	{0xA3e9,0x65},
	{0xA3ea,0xF0},
	{0xA3eb,0x02},
	{0xA3ec,0x67},
	{0xA3ed,0xA5},
	{0xA3f0,0x12},
	{0xA3f1,0x47},
	{0xA3f2,0x59},
	{0xA3f3,0x90},
	{0xA3f4,0x00},
	{0xA3f5,0xB5},
	{0xA3f6,0xE0},
	{0xA3f7,0xB4},
	{0xA3f8,0x02},
	{0xA3f9,0x03},
	{0xA3fa,0x12},
	{0xA3fb,0x47},
	{0xA3fc,0x59},
	{0xA3fd,0x02},
	{0xA3fe,0xC5},
	{0xA3ff,0xC3},
	{0xA400,0x90},
	{0xA401,0x00},
	{0xA402,0x3D},
	{0xA403,0xF0},
	{0xA404,0x90},
	{0xA405,0x00},
	{0xA406,0x84},
	{0xA407,0xE0},
	{0xA408,0xFE},
	{0xA409,0x90},
	{0xA40A,0x00},
	{0xA40B,0x3E},
	{0xA40C,0xF0},
	{0xA40D,0xEF},
	{0xA40E,0x70},
	{0xA40F,0x03},
	{0xA410,0xEE},
	{0xA411,0x60},
	{0xA412,0x04},
	{0xA413,0x7F},
	{0xA414,0x01},
	{0xA415,0x80},
	{0xA416,0x02},
	{0xA417,0x7F},
	{0xA418,0x00},
	{0xA419,0x90},
	{0xA41A,0x00},
	{0xA41B,0x3F},
	{0xA41C,0xEF},
	{0xA41D,0xF0},
	{0xA41E,0x02},
	{0xA41F,0x89},
	{0xA420,0xD3},
	{0xA421,0x90},
	{0xA422,0x00},
	{0xA423,0x12},
	{0xA424,0xE0},
	{0xA425,0xFF},
	{0xA426,0x70},
	{0xA427,0x0C},
	{0xA428,0x90},
	{0xA429,0x00},
	{0xA42A,0x46},
	{0xA42B,0xE0},
	{0xA42C,0xC3},
	{0xA42D,0x94},
	{0xA42E,0x07},
	{0xA42F,0x40},
	{0xA430,0x03},
	{0xA431,0x75},
	{0xA432,0x2E},
	{0xA433,0x02},
	{0xA434,0xEF},
	{0xA435,0xB4},
	{0xA436,0x01},
	{0xA437,0x0C},
	{0xA438,0x90},
	{0xA439,0x00},
	{0xA43A,0x66},
	{0xA43B,0xE0},
	{0xA43C,0xC3},
	{0xA43D,0x94},
	{0xA43E,0x07},
	{0xA43F,0x40},
	{0xA440,0x03},
	{0xA441,0x75},
	{0xA442,0x2E},
	{0xA443,0x02},
	{0xA444,0x02},
	{0xA445,0xA7},
	{0xA446,0x9E},
	{0xA447,0xC3},
	{0xA448,0x90},
	{0xA449,0x0B},
	{0xA44A,0x8F},
	{0xA44B,0xE0},
	{0xA44C,0x94},
	{0xA44D,0x80},
	{0xA44E,0x90},
	{0xA44F,0x0B},
	{0xA450,0x8E},
	{0xA451,0xE0},
	{0xA452,0x94},
	{0xA453,0x44},
	{0xA454,0x40},
	{0xA455,0x22},
	{0xA456,0x90},
	{0xA457,0x0B},
	{0xA458,0x91},
	{0xA459,0xE0},
	{0xA45A,0x94},
	{0xA45B,0x80},
	{0xA45C,0x90},
	{0xA45D,0x0B},
	{0xA45E,0x90},
	{0xA45F,0xE0},
	{0xA460,0x94},
	{0xA461,0x44},
	{0xA462,0x40},
	{0xA463,0x14},
	{0xA464,0x90},
	{0xA465,0x0B},
	{0xA466,0x93},
	{0xA467,0xE0},
	{0xA468,0x94},
	{0xA469,0x80},
	{0xA46A,0x90},
	{0xA46B,0x0B},
	{0xA46C,0x92},
	{0xA46D,0xE0},
	{0xA46E,0x94},
	{0xA46F,0x44},
	{0xA470,0x40},
	{0xA471,0x06},
	{0xA472,0x90},
	{0xA473,0x01},
	{0xA474,0xA4},
	{0xA475,0x02},
	{0xA476,0x86},
	{0xA477,0x57},
	{0xA478,0x02},
	{0xA479,0x86},
	{0xA47A,0x5C},
	{0xA500,0xF5},
	{0xA501,0x3B},
	{0xA502,0x90},
	{0xA503,0x06},
	{0xA504,0x6C},
	{0xA505,0xE0},
	{0xA506,0xFF},
	{0xA507,0xE5},
	{0xA508,0x3B},
	{0xA509,0xC3},
	{0xA50A,0x9F},
	{0xA50B,0x40},
	{0xA50C,0x03},
	{0xA50D,0x02},
	{0xA50E,0xF6},
	{0xA50F,0x0E},
	{0xA510,0x90},
	{0xA511,0x0B},
	{0xA512,0xC6},
	{0xA513,0xE0},
	{0xA514,0x14},
	{0xA515,0x60},
	{0xA516,0x3C},
	{0xA517,0x14},
	{0xA518,0x60},
	{0xA519,0x6B},
	{0xA51A,0x24},
	{0xA51B,0x02},
	{0xA51C,0x60},
	{0xA51D,0x03},
	{0xA51E,0x02},
	{0xA51F,0xF5},
	{0xA520,0xB5},
	{0xA521,0x90},
	{0xA522,0x0A},
	{0xA523,0x9A},
	{0xA524,0xE0},
	{0xA525,0xFB},
	{0xA526,0xA3},
	{0xA527,0xE0},
	{0xA528,0xFA},
	{0xA529,0xA3},
	{0xA52A,0xE0},
	{0xA52B,0xF9},
	{0xA52C,0x85},
	{0xA52D,0x3B},
	{0xA52E,0x82},
	{0xA52F,0x75},
	{0xA530,0x83},
	{0xA531,0x00},
	{0xA532,0x12},
	{0xA533,0x0A},
	{0xA534,0xB8},
	{0xA535,0xFF},
	{0xA536,0x74},
	{0xA537,0xAB},
	{0xA538,0x25},
	{0xA539,0x3B},
	{0xA53A,0xF5},
	{0xA53B,0x82},
	{0xA53C,0xE4},
	{0xA53D,0x34},
	{0xA53E,0x0A},
	{0xA53F,0xF5},
	{0xA540,0x83},
	{0xA541,0xE0},
	{0xA542,0xFD},
	{0xA543,0xC3},
	{0xA544,0xEF},
	{0xA545,0x9D},
	{0xA546,0xFE},
	{0xA547,0xE4},
	{0xA548,0x94},
	{0xA549,0x00},
	{0xA54A,0x90},
	{0xA54B,0x0B},
	{0xA54C,0xCA},
	{0xA54D,0xF0},
	{0xA54E,0xA3},
	{0xA54F,0xCE},
	{0xA550,0xF0},
	{0xA551,0x80},
	{0xA552,0x62},
	{0xA553,0x90},
	{0xA554,0x0A},
	{0xA555,0x9A},
	{0xA556,0xE0},
	{0xA557,0xFB},
	{0xA558,0xA3},
	{0xA559,0xE0},
	{0xA55A,0xFA},
	{0xA55B,0xA3},
	{0xA55C,0xE0},
	{0xA55D,0xF9},
	{0xA55E,0x85},
	{0xA55F,0x3B},
	{0xA560,0x82},
	{0xA561,0x75},
	{0xA562,0x83},
	{0xA563,0x00},
	{0xA564,0x12},
	{0xA565,0x0A},
	{0xA566,0xB8},
	{0xA567,0xFF},
	{0xA568,0x74},
	{0xA569,0x9D},
	{0xA56A,0x25},
	{0xA56B,0x3B},
	{0xA56C,0xF5},
	{0xA56D,0x82},
	{0xA56E,0xE4},
	{0xA56F,0x34},
	{0xA570,0x0A},
	{0xA571,0xF5},
	{0xA572,0x83},
	{0xA573,0xE0},
	{0xA574,0xFD},
	{0xA575,0xC3},
	{0xA576,0xEF},
	{0xA577,0x9D},
	{0xA578,0xFE},
	{0xA579,0xE4},
	{0xA57A,0x94},
	{0xA57B,0x00},
	{0xA57C,0x90},
	{0xA57D,0x0B},
	{0xA57E,0xCA},
	{0xA57F,0xF0},
	{0xA580,0xA3},
	{0xA581,0xCE},
	{0xA582,0xF0},
	{0xA583,0x80},
	{0xA584,0x30},
	{0xA585,0x90},
	{0xA586,0x0A},
	{0xA587,0x9A},
	{0xA588,0xE0},
	{0xA589,0xFB},
	{0xA58A,0xA3},
	{0xA58B,0xE0},
	{0xA58C,0xFA},
	{0xA58D,0xA3},
	{0xA58E,0xE0},
	{0xA58F,0xF9},
	{0xA590,0x85},
	{0xA591,0x3B},
	{0xA592,0x82},
	{0xA593,0x75},
	{0xA594,0x83},
	{0xA595,0x00},
	{0xA596,0x12},
	{0xA597,0x0A},
	{0xA598,0xB8},
	{0xA599,0xFF},
	{0xA59A,0x74},
	{0xA59B,0xA4},
	{0xA59C,0x25},
	{0xA59D,0x3B},
	{0xA59E,0xF5},
	{0xA59F,0x82},
	{0xA5A0,0xE4},
	{0xA5A1,0x34},
	{0xA5A2,0x0A},
	{0xA5A3,0xF5},
	{0xA5A4,0x83},
	{0xA5A5,0xE0},
	{0xA5A6,0xFD},
	{0xA5A7,0xC3},
	{0xA5A8,0xEF},
	{0xA5A9,0x9D},
	{0xA5AA,0xFE},
	{0xA5AB,0xE4},
	{0xA5AC,0x94},
	{0xA5AD,0x00},
	{0xA5AE,0x90},
	{0xA5AF,0x0B},
	{0xA5B0,0xCA},
	{0xA5B1,0xF0},
	{0xA5B2,0xA3},
	{0xA5B3,0xCE},
	{0xA5B4,0xF0},
	{0xA5B5,0x90},
	{0xA5B6,0x07},
	{0xA5B7,0x83},
	{0xA5B8,0xE0},
	{0xA5B9,0xFF},
	{0xA5BA,0x7E},
	{0xA5BB,0x00},
	{0xA5BC,0x90},
	{0xA5BD,0x0D},
	{0xA5BE,0xF6},
	{0xA5BF,0xEE},
	{0xA5C0,0xF0},
	{0xA5C1,0xA3},
	{0xA5C2,0xEF},
	{0xA5C3,0xF0},
	{0xA5C4,0x90},
	{0xA5C5,0x0B},
	{0xA5C6,0xCA},
	{0xA5C7,0xE0},
	{0xA5C8,0xFC},
	{0xA5C9,0xA3},
	{0xA5CA,0xE0},
	{0xA5CB,0xFD},
	{0xA5CC,0xD3},
	{0xA5CD,0x9F},
	{0xA5CE,0x74},
	{0xA5CF,0x80},
	{0xA5D0,0xF8},
	{0xA5D1,0xEC},
	{0xA5D2,0x64},
	{0xA5D3,0x80},
	{0xA5D4,0x98},
	{0xA5D5,0x40},
	{0xA5D6,0x0C},
	{0xA5D7,0x90},
	{0xA5D8,0x0B},
	{0xA5D9,0xC8},
	{0xA5DA,0xE0},
	{0xA5DB,0x04},
	{0xA5DC,0xF0},
	{0xA5DD,0xA3},
	{0xA5DE,0xE0},
	{0xA5DF,0x04},
	{0xA5E0,0xF0},
	{0xA5E1,0x80},
	{0xA5E2,0x26},
	{0xA5E3,0x90},
	{0xA5E4,0x0D},
	{0xA5E5,0xF6},
	{0xA5E6,0xE0},
	{0xA5E7,0xFE},
	{0xA5E8,0xA3},
	{0xA5E9,0xE0},
	{0xA5EA,0xFF},
	{0xA5EB,0xC3},
	{0xA5EC,0xE4},
	{0xA5ED,0x9F},
	{0xA5EE,0xFF},
	{0xA5EF,0xE4},
	{0xA5F0,0x9E},
	{0xA5F1,0xFE},
	{0xA5F2,0xC3},
	{0xA5F3,0xED},
	{0xA5F4,0x9F},
	{0xA5F5,0xEE},
	{0xA5F6,0x64},
	{0xA5F7,0x80},
	{0xA5F8,0xF8},
	{0xA5F9,0xEC},
	{0xA5FA,0x64},
	{0xA5FB,0x80},
	{0xA5FC,0x98},
	{0xA5FD,0x50},
	{0xA5FE,0x0A},
	{0xA5FF,0x90},
	{0xA600,0x0B},
	{0xA601,0xC8},
	{0xA602,0xE0},
	{0xA603,0x14},
	{0xA604,0xF0},
	{0xA605,0xA3},
	{0xA606,0xE0},
	{0xA607,0x04},
	{0xA608,0xF0},
	{0xA609,0x05},
	{0xA60A,0x3B},
	{0xA60B,0x02},
	{0xA60C,0xF5},
	{0xA60D,0x02},
	{0xA60E,0x90},
	{0xA60F,0x08},
	{0xA610,0x58},
	{0xA611,0x02},
	{0xA612,0x9D},
	{0xA613,0x50},
	{0x9006,0xBA},
	{0x9007,0x75},
	{0x9008,0x00},
	{0x9009,0x00},
	{0x900A,0x02},
	{0x900D,0x01},
	{0x900E,0xA2},
	{0x900F,0x8F},
	{0x9010,0x00},
	{0x9011,0xCB},
	{0x9012,0x03},
	{0x9016,0xE6},
	{0x9017,0x6B},
	{0x9018,0x02},
	{0x9019,0x6B},
	{0x901A,0x02},
	{0x901D,0x01},
	{0x901E,0xAC},
	{0x901F,0x70},
	{0x9020,0x00},
	{0x9021,0xC5},
	{0x9022,0x03},
	{0x9026,0x9C},
	{0x9027,0x5B},
	{0x9028,0x00},
	{0x9029,0xBF},
	{0x902A,0x02},
	{0x902E,0x60},
	{0x902F,0x1C},
	{0x9030,0x01},
	{0x9031,0x37},
	{0x9032,0x02},
	{0x9035,0x01},
	{0x9036,0xBA},
	{0x9037,0x70},
	{0x9038,0x00},
	{0x9039,0x00},
	{0x903A,0x03},
	{0x903E,0x21},
	{0x903F,0x3F},
	{0x9040,0x02},
	{0x9041,0x40},
	{0x9042,0x02},
	{0x9046,0x21},
	{0x9047,0xEA},
	{0x9048,0x02},
	{0x9049,0x43},
	{0x904A,0x02},
	{0x904E,0xA6},
	{0x904F,0x12},
	{0x9050,0x02},
	{0x9051,0x46},
	{0x9052,0x02},
	{0x9056,0x29},
	{0x9057,0xE3},
	{0x9058,0x02},
	{0x9059,0x49},
	{0x905A,0x02},
	{0x905D,0x01},
	{0x905E,0x9C},
	{0x905F,0x6E},
	{0x9060,0x05},
	{0x9061,0x00},
	{0x9062,0x02},
	{0x9065,0x01},
	{0x9066,0xA2},
	{0x9067,0x66},
	{0x9068,0x02},
	{0x9069,0x35},
	{0x906A,0x02},
	{0x906D,0x01},
	{0x906E,0xB5},
	{0x906F,0xC2},
	{0x9070,0x02},
	{0x9071,0x9B},
	{0x9072,0x02},
	{0x9075,0x01},
	{0x9076,0xA2},
	{0x9077,0xD4},
	{0x9078,0x02},
	{0x9079,0xBE},
	{0x907A,0x02},
	{0x907D,0x01},
	{0x907E,0xB7},
	{0x907F,0xEA},
	{0x9080,0x00},
	{0x9081,0x02},
	{0x9082,0x03},
	{0x9086,0x67},
	{0x9087,0x31},
	{0x9088,0x02},
	{0x9089,0xF7},
	{0x908A,0x02},
	{0x908E,0x66},
	{0x908F,0xED},
	{0x9090,0x03},
	{0x9091,0x1D},
	{0x9092,0x02},
	{0x9096,0x67},
	{0x9097,0x73},
	{0x9098,0x03},
	{0x9099,0xD3},
	{0x909A,0x02},
	{0x909E,0x20},
	{0x909F,0x40},
	{0x90A0,0x03},
	{0x90A1,0x3B},
	{0x90A2,0x02},
	{0x90A6,0xC5},
	{0x90A7,0xC0},
	{0x90A8,0x03},
	{0x90A9,0xF0},
	{0x90AA,0x02},
	{0x90AE,0x41},
	{0x90AF,0xB3},
	{0x90B0,0x00},
	{0x90B1,0xA2},
	{0x90B2,0x02},
	{0x90B6,0x44},
	{0x90B7,0xBA},
	{0x90B8,0x00},
	{0x90B9,0xF0},
	{0x90BA,0x03},
	{0x90BE,0x89},
	{0x90BF,0x99},
	{0x90C0,0x04},
	{0x90C1,0x00},
	{0x90C2,0x02},
	{0x90C6,0xA7},
	{0x90C7,0x91},
	{0x90C8,0x04},
	{0x90C9,0x21},
	{0x90CA,0x02},
	{0x90CE,0x3A},
	{0x90CF,0x51},
	{0x90D0,0x00},
	{0x90D1,0xA2},
	{0x90D2,0x02},
	{0x90D6,0x86},
	{0x90D7,0x54},
	{0x90D8,0x04},
	{0x90D9,0x47},
	{0x90DA,0x02},
	{0x9000,0x01},
	{0xFFFF,0x00},
	{REG_DLY,200},//mdelay(200)

	{0x0009,0x16},
	{0x0012,0x00},
	{0x0013,0x00},
	{0x0016,0x00},
	{0x0021,0x00},
	{0x0022,0x01},
	{0x0040,0x01},
	{0x0041,0x04},
	{0x0042,0x05},
	{0x0043,0x00},
	{0x0044,0x03},
	{0x0045,0xC0},
	{0x0046,0x02},
	{0x0060,0x00},
	{0x0061,0x00},
	{0x0066,0x02},
	{0x0083,0x00},
	{0x0084,0x01},
	//{0x0085,0x02},
	{0x00B2,0x4f},
	{0x00B3,0x70},
	{0x00B4,0x01},
	//{0x00B5,0x01},
	{0x00E8,0x01},
	//{0x00ED,0x05},
	{0x00EE,0x1E},
	{0x0129,0x00},
	{0x0130,0x00},
	{0x0137,0x00},
	{0x019C,0x4B},
	{0x019D,0xC0},
	{0x01A0,0x01},
	{0x01A1,0x80},
	{0x01A2,0x80},
	{0x01A3,0x80},
	{0x5200,0x01},
	{0x7000,0x0C},
	{0x7101,0x44},//c4
	{0x7102,0x01},
	{0x7103,0x00},
	{0x7104,0x00},
	{0x7105,0x80},
	{0x7158,0x00},
	{0x0143,0x5F},
	{0x0144,0x0D},
	{0x0046,0x00},
	{0x0041,0x00},
	//{0x00B5,0x02},
	{0x7101,0x44},
	{0x00ED,0x0A},
	{0x00EE,0x1E},
	//{0x00B3,0x80},
	{0x019C,0x4B},
	{0x019D,0xC0},
	{0x0129,0x00},
	{0x0130,0xFF},
	{0x0083,0x01},
	{0x0084,0x00},
	{0x01A1,0x80},
	{0x01A2,0x80},
	{0x01A3,0x80},
	{0x01A0,0x01},
	{0x0021,0x00},
	{0x0022,0x01},
	{0x0040,0x01},
	{0x0060,0x00},
	{0x0013,0x00},
	{0x0041,0x04},
	{0x0061,0x00},
	{0x0046,0x02},//02   gong
	{0x0066,0x02},   //02 gong
	{0x0012,0x00},
	{0x7102,0x09},
	{0x7103,0x00},
	{0x7158,0x00},
	{0x00E8,0x01},
	{0x7000,0x2C},
	{0x5200,0x01},
	{0x7000,0x0C},
	{0x02C2,0x00},
	{0x02C3,0xC0},
	{0x015E,0x40},
	{0x015F,0x00},
	{0x0390,0x01},
	{0x0391,0x00},
	{0x0392,0x00},
	{0x03A0,0x14},
	{0x03A1,0x00},
	{0x03A2,0x5A},
	{0x03A3,0xEE},
	{0x03A4,0x69},
	{0x03A5,0x49},
	{0x03A6,0x3E},
	{0x03A7,0x00},
	{0x03A8,0x39},
	{0x03A9,0x33},
	{0x03B0,0x60},
	{0x03B1,0x00},
	{0x03B2,0x5A},
	{0x03B3,0xEE},
	{0x03B4,0x69},
	{0x03B5,0x49},
	{0x03B6,0x3E},
	{0x03B7,0x00},
	{0x03B8,0x3D},
	{0x03B9,0x20},
	{0x03C0,0x10},
	{0x03C1,0x00},
	{0x03C2,0x5A},
	{0x03C3,0xEE},
	{0x03C4,0x69},
	{0x03C5,0x49},
	{0x03C6,0x3A},
	{0x03C7,0x80},
	{0x03D0,0x64},
	{0x03D1,0x00},
	{0x03D2,0x5A},
	{0x03D3,0xEE},
	{0x03D4,0x69},
	{0x03D5,0x49},
	{0x03D6,0x34},
	{0x03D7,0xD1},
	{0x004C,0x08},
	{0x006C,0x08},
	{0x0350,0x00},
	{0x0351,0x5A},
	{0x0352,0xEE},
	{0x0353,0x69},
	{0x0354,0x49},
	{0x0355,0x39},
	{0x0356,0x6D},
	{0x0357,0x19},
	{0x0358,0x00},
	{0x0359,0x3C},
	{0x035A,0x5A},
	{0x035B,0xEE},
	{0x035C,0x69},
	{0x035D,0x49},
	{0x035E,0x39},
	{0x035F,0x85},
	{0x0049,0x14},
	{0x004A,0x0D},
	{0x0069,0x14},
	{0x006A,0x0D},
	{0x0090,0x5A},
	{0x0091,0xEE},
	{0x0092,0x3E},
	{0x0093,0x00},
	{0x0094,0x69},
	{0x0095,0x49},
	{0x0096,0x39},
	{0x0097,0xCF},
	{0x0098,0x00},
	{0x00A0,0x5A},
	{0x00A1,0xEE},
	{0x00A2,0x3E},
	{0x00A3,0x00},
	{0x00A4,0x69},
	{0x00A5,0x49},
	{0x00A6,0x3B},
	{0x00A7,0x80},
	{0x00A8,0x00},
	{0x0420,0x00},
	{0x0421,0x09},
	{0x0422,0xff},
	{0x0423,0x9e},
	{0x0424,0x00},
	{0x0425,0x89},
	{0x0426,0x00},
	{0x0427,0xab},
	{0x0428,0xff},
	{0x0429,0xe9},
	{0x042a,0xff},
	{0x042b,0x8b},
	{0x042c,0x00},
	{0x042d,0x73},
	{0x042E,0xff},
	{0x042f,0xb6},
	{0x0430,0x00},
	{0x0431,0x54},
	{0x0432,0xff},
	{0x0433,0x43},
	{0x0434,0x01},
	{0x0435,0x04},
	{0x0436,0x01},
	{0x0437,0x34},
	{0x0438,0xff},
	{0x0439,0x7c},
	{0x043a,0xfe},
	{0x043b,0xd2},
	{0x043c,0x00},
	{0x043d,0x63},
	{0x043e,0xff},
	{0x043f,0x15},
	{0x0450,0x00},
	{0x0451,0x3b},
	{0x0452,0xff},
	{0x0453,0x98},
	{0x0454,0x00},
	{0x0455,0x6f},
	{0x0456,0x00},
	{0x0457,0x93},
	{0x0458,0xff},
	{0x0459,0xad},
	{0x045a,0xff},
	{0x045b,0x87},
	{0x045c,0x00},
	{0x045d,0x52},
	{0x045E,0xff},
	{0x045f,0xa7},
	{0x0440,0xff},
	{0x0441,0xfd},
	{0x0442,0xff},
	{0x0443,0x6c},
	{0x0444,0x00},
	{0x0445,0x90},
	{0x0446,0x00},
	{0x0447,0xa1},
	{0x0448,0x00},
	{0x0449,0x02},
	{0x044a,0xff},
	{0x044b,0x48},
	{0x044c,0x00},
	{0x044d,0x5b},
	{0x044E,0xff},
	{0x044f,0xb4},
	{0x0460,0xff},
	{0x0461,0x69},
	{0x0462,0xff},
	{0x0463,0xbb},
	{0x0464,0x00},
	{0x0465,0x84},
	{0x0466,0x00},
	{0x0467,0xa3},
	{0x0468,0x00},
	{0x0469,0x0e},
	{0x046A,0x00},
	{0x046b,0x76},
	{0x046C,0xff},
	{0x046d,0xaf},
	{0x046E,0xff},
	{0x046f,0xf5},
	{0x0470,0xff},
	{0x0471,0x8a},
	{0x0472,0xff},
	{0x0473,0x5a},
	{0x0474,0x00},
	{0x0475,0xef},
	{0x0476,0x01},
	{0x0477,0x16},
	{0x0478,0xff},
	{0x0479,0xd4},
	{0x047A,0x00},
	{0x047b,0x02},
	{0x047c,0x00},
	{0x047d,0x2c},
	{0x047E,0xff},
	{0x047f,0x95},
	{0x0490,0xff},
	{0x0491,0x9b},
	{0x0492,0xff},
	{0x0493,0x91},
	{0x0494,0x00},
	{0x0495,0x6f},
	{0x0496,0x00},
	{0x0497,0x95},
	{0x0498,0xff},
	{0x0499,0xd5},
	{0x049a,0x01},
	{0x049b,0x20},
	{0x049C,0xff},
	{0x049d,0xfb},
	{0x049E,0xff},
	{0x049f,0xe1},
	{0x0480,0xff},
	{0x0481,0x5a},
	{0x0482,0xff},
	{0x0483,0x91},
	{0x0484,0x00},
	{0x0485,0x8c},
	{0x0486,0x00},
	{0x0487,0x9f},
	{0x0488,0x00},
	{0x0489,0x29},
	{0x048A,0x00},
	{0x048b,0x53},
	{0x048C,0xff},
	{0x048d,0x80},
	{0x048E,0xff},
	{0x048f,0xf7},
	{0x04A0,0xff},
	{0x04a1,0x6c},
	{0x04a2,0xff},
	{0x04a3,0xb9},
	{0x04A4,0x00},
	{0x04a5,0x81},
	{0x04A6,0x00},
	{0x04a7,0x93},
	{0x04A8,0x00},
	{0x04A9,0x1c},
	{0x04AA,0x00},
	{0x04ab,0x39},
	{0x04AC,0xff},
	{0x04ad,0x9f},
	{0x04ae,0x00},
	{0x04af,0x0e},
	{0x04B0,0xff},
	{0x04b1,0xe0},
	{0x04B2,0xff},
	{0x04b3,0x7b},
	{0x04B4,0x00},
	{0x04b5,0xaa},
	{0x04B6,0x00},
	{0x04b7,0xc8},
	{0x04B8,0xff},
	{0x04b9,0xe1},
	{0x04BA,0x00},
	{0x04bb,0x0e},
	{0x04bc,0x00},
	{0x04bd,0x0b},
	{0x04be,0xff},
	{0x04bf,0xff},
	{0x04D0,0xff},
	{0x04d1,0xac},
	{0x04D2,0xff},
	{0x04d3,0x93},
	{0x04D4,0x00},
	{0x04d5,0x64},
	{0x04D6,0x00},
	{0x04d7,0x83},
	{0x04D8,0xff},
	{0x04d9,0xdb},
	{0x04DA,0x00},
	{0x04db,0xa8},
	{0x04DC,0xff},
	{0x04dd,0xf5},
	{0x04de,0x00},
	{0x04df,0x15},
	{0x04C0,0xff},
	{0x04c1,0x5d},
	{0x04c2,0xff},
	{0x04c3,0x9c},
	{0x04C4,0x00},
	{0x04c5,0x82},
	{0x04C6,0x00},
	{0x04c7,0x96},
	{0x04C8,0x00},
	{0x04c9,0x33},
	{0x04CA,0x00},
	{0x04cb,0x07},
	{0x04CC,0xff},
	{0x04cd,0x71},
	{0x04ce,0x00},
	{0x04cf,0x11},
	{0x04E0,0xff},
	{0x04e1,0x6d},
	{0x04e2,0xff},
	{0x04e3,0xb8},
	{0x04E4,0x00},
	{0x04e5,0x84},
	{0x04E6,0x00},
	{0x04e7,0x96},
	{0x04e8,0xff},
	{0x04e9,0xc0},
	{0x04EA,0x00},
	{0x04eb,0x6d},
	{0x04EC,0xff},
	{0x04ed,0xbb},
	{0x04ee,0x00},
	{0x04ef,0x00},
	{0x04F0,0xff},
	{0x04f1,0xe0},
	{0x04F2,0xff},
	{0x04f3,0x95},
	{0x04F4,0x00},
	{0x04f5,0xa7},
	{0x04F6,0x00},
	{0x04f7,0xc8},
	{0x04F8,0xff},
	{0x04f9,0xde},
	{0x04FA,0x00},
	{0x04fb,0x7e},
	{0x04fc,0x00},
	{0x04fd,0x36},
	{0x04fe,0x00},
	{0x04ff,0x10},
	{0x0510,0xff},
	{0x0511,0xc1},
	{0x0512,0xff},
	{0x0513,0x9f},
	{0x0514,0x00},
	{0x0515,0x6a},
	{0x0516,0x00},
	{0x0517,0x89},
	{0x0518,0xff},
	{0x0519,0xdc},
	{0x051A,0x00},
	{0x051b,0x55},
	{0x051c,0x00},
	{0x051d,0x09},
	{0x051e,0x00},
	{0x051f,0x0d},
	{0x0500,0xff},
	{0x0501,0x60},
	{0x0502,0xff},
	{0x0503,0x9e},
	{0x0504,0x00},
	{0x0505,0x81},
	{0x0506,0x00},
	{0x0507,0x9c},
	{0x0508,0xff},
	{0x0509,0xc0},
	{0x050A,0x00},
	{0x050b,0x40},
	{0x050C,0xff},
	{0x050d,0x8e},
	{0x050e,0x00},
	{0x050f,0x00},
	{0x0561,0x0e},
	{0x0562,0x01},
	{0x0563,0x01},
	{0x0564,0x06},
	{0x0324,0x39},
	{0x0325,0xAE},
	{0x0326,0x3a},
	{0x0327,0x29},
	{0x0328,0x3b},
	{0x0329,0x0A},
	{0x032A,0x3b},
	{0x032B,0x62},
	{0x0320,0x01},
	{0x0321,0x04},
	{0x0322,0x01},
	{0x0323,0x01},
	{0x0330,0x01},
	{0x0384,0x00},
	{0x0337,0x01},
	{0x03EC,0x39},
	{0x03ED,0x85},
	{0x03FC,0x3A},
	{0x03FD,0x14},
	{0x040C,0x3A},
	{0x040D,0xF6},
	{0x041C,0x3B},
	{0x041D,0x9A},
	{0x03E0,0xB6},
	{0x03E1,0x04},
	{0x03E2,0xBB},
	{0x03E3,0xE9},
	{0x03E4,0xBC},
	{0x03E5,0x70},
	{0x03E6,0x37},
	{0x03E7,0x02},
	{0x03E8,0xBC},
	{0x03E9,0x00},
	{0x03EA,0xBF},
	{0x03EB,0x12},
	{0x03F0,0xBA},
	{0x03F1,0x7B},
	{0x03F2,0xBA},
	{0x03F3,0x83},
	{0x03F4,0xBB},
	{0x03F5,0xBC},
	{0x03F6,0x38},
	{0x03F7,0x2D},
	{0x03F8,0xBB},
	{0x03F9,0x23},
	{0x03FA,0xBD},
	{0x03FB,0xAC},
	{0x0400,0xBE},
	{0x0401,0x96},
	{0x0402,0xB9},
	{0x0403,0xBE},
	{0x0404,0xBB},
	{0x0405,0x57},
	{0x0406,0x3A},
	{0x0407,0xBB},
	{0x0408,0xB3},
	{0x0409,0x17},
	{0x040A,0xBE},
	{0x040B,0x66},
	{0x0410,0xBB},
	{0x0411,0x2A},
	{0x0412,0xBA},
	{0x0413,0x00},
	{0x0414,0xBB},
	{0x0415,0x10},
	{0x0416,0xB8},
	{0x0417,0xCD},
	{0x0418,0xB7},
	{0x0419,0x5C},
	{0x041A,0xBB},
	{0x041B,0x6C},
	{0x01f8,0x3c},
	{0x01f9,0x00},
	{0x01FA,0x00},
	{0x02a2,0x3e},
	{0x02a3,0x00},
	{0x02a4,0x3e},
	{0x02a5,0x00},
	{0x02a6,0x3e},
	{0x02a7,0x00},
	{0x02a8,0x3e},
	{0x02a9,0x00},
	{0x056c,0x42},
	{0x056d,0x00},
	{0x056e,0x42},
	{0x056f,0x00},
	{0x0570,0x42},
	{0x0571,0x00},
	{0x0572,0x42},
	{0x0573,0x00},
	{0x0081,0x6E},
	{0x0588,0x00},
	{0x0589,0x5A},
	{0x058A,0xEE},
	{0x058B,0x69},
	{0x058C,0x49},
	{0x058D,0x3D},
	{0x058E,0x3D},
	{0x0080,0x6C},
	{0x0082,0x5A},
	//{0x0010,0x01},
	//{REG_DLY,200},//mdelay(200)

	{0x4708,0x00},
	{0x4709,0x00},
	{0x4710,0x00},
	{0x4711,0x00},
	{0x065A,0x00},
	{0x06C9,0x01},
	{0x06CD,0x01},
	{0x06CE,0xBD},
	{0x06CF,0x00},
	{0x06D0,0x93},
	{0x06D1,0x02},
	{0x06D2,0x30},
	{0x06D3,0xD4},
	{0x06D4,0x01},
	{0x06D5,0x01},
	{0x06D6,0xBD},
	{0x06D7,0x00},
	{0x06D8,0x93},
	{0x06D9,0x00},
	{0x06DA,0x93},
	{0x06DB,0x59},
	{0x06DC,0x0d},
	{0x0730,0x00},
	{0x0731,0x00},
	{0x0732,0x03},
	{0x0733,0xFF},
	{0x0734,0x03},
	{0x0735,0x70},
	{0x0755,0x01},
	{0x0756,0x00},
	{0x075B,0x01},
	{0x075E,0x00},
	{0x0764,0x01},
	{0x0766,0x01},
	{0x0768,0x01},
	{0x076A,0x00},
	{0x0758,0x01},
	{0x075C,0x01},
	{0x0770,0x98},
	{0x0771,0x19},
	{0x0772,0x1B},
	{0x0774,0x01},
	{0x0775,0x4a},
	{0x0777,0x00},
	{0x0778,0x45},
	{0x0779,0x00},
	{0x077A,0x02},
	{0x077D,0x01},
	{0x077E,0x03},
	{0x0783,0x10},
	{0x0785,0x14},
	{0x0788,0x04},
	{0x0846,0x06},
	{0x0847,0x05},
	{0xC41A,0x05},
	{0xC423,0x11},
	{0xC427,0x11},
	{0x300B,0x09},
	{0x0085,0x02},//yuv order
	{0x7000,0x08},
	{0x5200,0x09},
	{0x00B5,0x01},
	{0x0030,0x14},
	{0x0040,0x01},
	{0x0041,0x04},
	{0x00B4,0x01},

	{0x0010,0x01},
	{REG_DLY,100},//mdelay(200)
	{0x070A,0x01},
	//{0x0010,0x01},
	{REG_DLY,100},//mdelay(200)
};

//for capture
static struct regval_list sensor_qsxga_regs[] = { //qsxga: 2592*1936
	//capture 5Mega 5fps
	{0x0010,0x02},
	{0x00ED,0x05},
	//{0x0085,0x02},//yuv order 00
	{0x7000,0x08},
	{0x5200,0x09},
	//{0x00B2,0x50},
	//{0x00B3,0x80},
	//{0x00B5,0x02},
	{0x0030,0x12},
	{0x0040,0x00},
	{0x0041,0x00},
	{0x00B4,0x01},
	{0x0010,0x01},
};

static struct regval_list sensor_qxga_regs[] = { //qxga: 2048*1536
  //capture 3Mega 7.5fps
	{0x0010,0x02},
	{0x7000,0x08},
	{0x5200,0x09},
	{0x00ED,0x05},
	//{0x00B2,0x50},
	//{0x00B3,0x80},
	//{0x00B5,0x02},
	{0x0030,0x12},
	{0x0040,0x00},
	{0x0041,0x0a},
	{0x0042,0x08},
	{0x0043,0x00},
	{0x0044,0x06},
	{0x0045,0x00},
	{0x00B4,0x01},
	{0x0010,0x01},
};

static struct regval_list sensor_uxga_regs[] = { //UXGA: 1600*1200
		//capture 2Mega 5fps
	//{0x0085,0x02},//yuv order 00
	{0x0010,0x02},
	{0x7000,0x08},
	{0x5200,0x09},
	{0x00ED,0x05},
	//{0x00B2,0x50},
	//{0x00B3,0x80},
	//{0x00B5,0x02},
	{0x0030,0x12},
	{0x0040,0x00},
	{0x0041,0x01},
	{0x00B4,0x01},
	{0x0010,0x01},
};
static struct regval_list sensor_sxga_regs[] = { //SXGA: 1280*1024
	//capture 1.3Mega 5fps
	//{0x0085,0x02},//yuv order 00
	{0x0010,0x02},
	{0x7000,0x08},
	{0x5200,0x09},
	{0x00ED,0x05},
	//{0x00B2,0x50},
	//{0x00B3,0x80},
	//{0x00B5,0x02},
	{0x0030,0x12},
	{0x0040,0x00},
	{0x0041,0x02},
	{0x00B4,0x01},
	{0x0010,0x01},
};

static struct regval_list sensor_xga_regs[] = { //XGA: 1024*768
	//capture 1Mega 5fps
	//{0x00,0x85,0x02},//yuv order 00
	{0x0010,0x02},
	{0x7000,0x08},
	{0x5200,0x09},
	{0x00ED,0x05},
	//{0x00B2,0x50},
	//{0x00B3,0x80},
	//{0x00B5,0x02},
	{0x0030,0x12},
	{0x0040,0x01},
	{0x0041,0x0a},
	{0x0042,0x04},
	{0x0043,0x00},
	{0x0044,0x03},
	{0x0045,0x00},

	{0x00B4,0x01},
	{0x0010,0x01},
};

//for video
static struct regval_list sensor_1080p_regs[] = { //1080: 1920*1080
	{0x0010,0x02},
	{0x7000,0x08},
	{0x5200,0x09},
	//{0x00B2,0x50},
	//{0x00B3,0x80},
	//{0x00B5,0x02},
	{0x0030,0x12},
	{0x0040,0x01},
	{0x0041,0x0a},
	{0x0042,0x07},
	{0x0043,0x80},
	{0x0044,0x04},
	{0x0045,0x38},

	{0x00B4,0x01},
	{0x0010,0x01},
};

static struct regval_list sensor_720p_regs[] = { //1280*720
	{0x0010,0x02},
	{0x7000,0x08},
	{0x00ED,0x0A},//fps
	{0x5200,0x09},
	//{0x00B2,0x50},
	//{0x00B3,0x80},
	//{0x00B5,0x02},
	{0x0030,0x12},
	{0x0040,0x01},
	{0x0041,0x0a},
	{0x0042,0x05},
	{0x0043,0x00},
	{0x0044,0x02},
	{0x0045,0xd0},

	{0x00B4,0x01},
	{0x0010,0x01},
};

static struct regval_list sensor_svga_regs[] = { //SVGA: 800*600
	{0x0010,0x02},
	{0x7000,0x08},
	{0x5200,0x09},
	{0x00ED,0x0A},
	//{0x00B2,0x50},
	//{0x00B3,0x80},
	//{0x00B5,0x02},
	{0x0030,0x12},
	{0x0040,0x00},
	{0x0041,0x03},
	{0x00B4,0x01},
	{0x0010,0x01},
};

static struct regval_list sensor_vga_regs[] = { //VGA:  640*480
	//timing
	//640x480
	//power down
	//{0x0010,0x02},

	//{0x0085,0x02},//yuv order 00
	//{0x0010,0x02},
	{0x7000,0x08},
	{0x5200,0x09},
	{0x00ED,0x0A},
	//{0x00B2,0x50},//50
	//{0x00B3,0xB0},//b0
	//{0x00B5,0x02},//02
	{0x0030,0x14},//11
	{0x0040,0x01},
	{0x0041,0x04},
	{0x00B4,0x01},
	//{0x0010,0x01},
	//{0x070A,0x01},



};
static char sensor_af_fw_regs[] = {
	0x02, 0x0f, 0xd6, 0x02, 0x0a, 0x39, 0xc2, 0x01, 0x22, 0x22, 0x00, 0x02, 0x0f, 0xb2, 0xe5, 0x1f, //0x8000,
	0x70, 0x72, 0xf5, 0x1e, 0xd2, 0x35, 0xff, 0xef, 0x25, 0xe0, 0x24, 0x4e, 0xf8, 0xe4, 0xf6, 0x08, //0x8010,
	0xf6, 0x0f, 0xbf, 0x34, 0xf2, 0x90, 0x0e, 0x93, 0xe4, 0x93, 0xff, 0xe5, 0x4b, 0xc3, 0x9f, 0x50, //0x8020,
	0x04, 0x7f, 0x05, 0x80, 0x02, 0x7f, 0xfb, 0x78, 0xbd, 0xa6, 0x07, 0x12, 0x0f, 0x04, 0x40, 0x04, //0x8030,
	0x7f, 0x03, 0x80, 0x02, 0x7f, 0x30, 0x78, 0xbc, 0xa6, 0x07, 0xe6, 0x18, 0xf6, 0x08, 0xe6, 0x78, //0x8040,
	0xb9, 0xf6, 0x78, 0xbc, 0xe6, 0x78, 0xba, 0xf6, 0x78, 0xbf, 0x76, 0x33, 0xe4, 0x08, 0xf6, 0x78, //0x8050,
	0xb8, 0x76, 0x01, 0x75, 0x4a, 0x02, 0x78, 0xb6, 0xf6, 0x08, 0xf6, 0x74, 0xff, 0x78, 0xc1, 0xf6, //0x8060,
	0x08, 0xf6, 0x75, 0x1f, 0x01, 0x78, 0xbc, 0xe6, 0x75, 0xf0, 0x05, 0xa4, 0xf5, 0x4b, 0x12, 0x0a, //0x8070,
	0xff, 0xc2, 0x37, 0x22, 0x78, 0xb8, 0xe6, 0xd3, 0x94, 0x00, 0x40, 0x02, 0x16, 0x22, 0xe5, 0x1f, //0x8080,
	0xb4, 0x05, 0x23, 0xe4, 0xf5, 0x1f, 0xc2, 0x01, 0x78, 0xb6, 0xe6, 0xfe, 0x08, 0xe6, 0xff, 0x78, //0x8090,
	0x4e, 0xa6, 0x06, 0x08, 0xa6, 0x07, 0xa2, 0x37, 0xe4, 0x33, 0xf5, 0x3c, 0x90, 0x30, 0x28, 0xf0, //0x80a0,
	0x75, 0x1e, 0x10, 0xd2, 0x35, 0x22, 0xe5, 0x4b, 0x75, 0xf0, 0x05, 0x84, 0x78, 0xbc, 0xf6, 0x90, //0x80b0,
	0x0e, 0x8c, 0xe4, 0x93, 0xff, 0x25, 0xe0, 0x24, 0x0a, 0xf8, 0xe6, 0xfc, 0x08, 0xe6, 0xfd, 0x78, //0x80c0,
	0xbc, 0xe6, 0x25, 0xe0, 0x24, 0x4e, 0xf8, 0xa6, 0x04, 0x08, 0xa6, 0x05, 0xef, 0x12, 0x0f, 0x0b, //0x80d0,
	0xd3, 0x78, 0xb7, 0x96, 0xee, 0x18, 0x96, 0x40, 0x0d, 0x78, 0xbc, 0xe6, 0x78, 0xb9, 0xf6, 0x78, //0x80e0,
	0xb6, 0xa6, 0x06, 0x08, 0xa6, 0x07, 0x90, 0x0e, 0x8c, 0xe4, 0x93, 0x12, 0x0f, 0x0b, 0xc3, 0x78, //0x80f0,
	0xc2, 0x96, 0xee, 0x18, 0x96, 0x50, 0x0d, 0x78, 0xbc, 0xe6, 0x78, 0xba, 0xf6, 0x78, 0xc1, 0xa6, //0x8100,
	0x06, 0x08, 0xa6, 0x07, 0x78, 0xb6, 0xe6, 0xfe, 0x08, 0xe6, 0xc3, 0x78, 0xc2, 0x96, 0xff, 0xee, //0x8110,
	0x18, 0x96, 0x78, 0xc3, 0xf6, 0x08, 0xa6, 0x07, 0x90, 0x0e, 0x95, 0xe4, 0x18, 0x12, 0x0e, 0xe9, //0x8120,
	0x40, 0x02, 0xd2, 0x37, 0x78, 0xbc, 0xe6, 0x08, 0x26, 0x08, 0xf6, 0xe5, 0x1f, 0x64, 0x01, 0x70, //0x8130,
	0x4a, 0xe6, 0xc3, 0x78, 0xc0, 0x12, 0x0e, 0xdf, 0x40, 0x05, 0x12, 0x0e, 0xda, 0x40, 0x39, 0x12, //0x8140,
	0x0f, 0x02, 0x40, 0x04, 0x7f, 0xfe, 0x80, 0x02, 0x7f, 0x02, 0x78, 0xbd, 0xa6, 0x07, 0x78, 0xb9, //0x8150,
	0xe6, 0x24, 0x03, 0x78, 0xbf, 0xf6, 0x78, 0xb9, 0xe6, 0x24, 0xfd, 0x78, 0xc0, 0xf6, 0x12, 0x0f, //0x8160,
	0x02, 0x40, 0x06, 0x78, 0xc0, 0xe6, 0xff, 0x80, 0x04, 0x78, 0xbf, 0xe6, 0xff, 0x78, 0xbe, 0xa6, //0x8170,
	0x07, 0x75, 0x1f, 0x02, 0x78, 0xb8, 0x76, 0x01, 0x02, 0x02, 0x4a, 0xe5, 0x1f, 0x64, 0x02, 0x60, //0x8180,
	0x03, 0x02, 0x02, 0x2a, 0x78, 0xbe, 0xe6, 0xff, 0xc3, 0x78, 0xc0, 0x12, 0x0e, 0xe0, 0x40, 0x08, //0x8190,
	0x12, 0x0e, 0xda, 0x50, 0x03, 0x02, 0x02, 0x28, 0x12, 0x0f, 0x02, 0x40, 0x04, 0x7f, 0xff, 0x80, //0x81a0,
	0x02, 0x7f, 0x01, 0x78, 0xbd, 0xa6, 0x07, 0x78, 0xb9, 0xe6, 0x04, 0x78, 0xbf, 0xf6, 0x78, 0xb9, //0x81b0,
	0xe6, 0x14, 0x78, 0xc0, 0xf6, 0x18, 0x12, 0x0f, 0x04, 0x40, 0x04, 0xe6, 0xff, 0x80, 0x02, 0x7f, //0x81c0,
	0x00, 0x78, 0xbf, 0xa6, 0x07, 0xd3, 0x08, 0xe6, 0x64, 0x80, 0x94, 0x80, 0x40, 0x04, 0xe6, 0xff, //0x81d0,
	0x80, 0x02, 0x7f, 0x00, 0x78, 0xc0, 0xa6, 0x07, 0xc3, 0x18, 0xe6, 0x64, 0x80, 0x94, 0xb3, 0x50, //0x81e0,
	0x04, 0xe6, 0xff, 0x80, 0x02, 0x7f, 0x33, 0x78, 0xbf, 0xa6, 0x07, 0xc3, 0x08, 0xe6, 0x64, 0x80, //0x81f0,
	0x94, 0xb3, 0x50, 0x04, 0xe6, 0xff, 0x80, 0x02, 0x7f, 0x33, 0x78, 0xc0, 0xa6, 0x07, 0x12, 0x0f, //0x8200,
	0x02, 0x40, 0x06, 0x78, 0xc0, 0xe6, 0xff, 0x80, 0x04, 0x78, 0xbf, 0xe6, 0xff, 0x78, 0xbe, 0xa6, //0x8210,
	0x07, 0x75, 0x1f, 0x03, 0x78, 0xb8, 0x76, 0x01, 0x80, 0x20, 0xe5, 0x1f, 0x64, 0x03, 0x70, 0x26, //0x8220,
	0x78, 0xbe, 0xe6, 0xff, 0xc3, 0x78, 0xc0, 0x12, 0x0e, 0xe0, 0x40, 0x05, 0x12, 0x0e, 0xda, 0x40, //0x8230,
	0x09, 0x78, 0xb9, 0xe6, 0x78, 0xbe, 0xf6, 0x75, 0x1f, 0x04, 0x78, 0xbe, 0xe6, 0x75, 0xf0, 0x05, //0x8240,
	0xa4, 0xf5, 0x4b, 0x02, 0x0a, 0xff, 0xe5, 0x1f, 0xb4, 0x04, 0x10, 0x90, 0x0e, 0x94, 0xe4, 0x78, //0x8250,
	0xc3, 0x12, 0x0e, 0xe9, 0x40, 0x02, 0xd2, 0x37, 0x75, 0x1f, 0x05, 0x22, 0x30, 0x01, 0x03, 0x02, //0x8260,
	0x04, 0xc0, 0x30, 0x02, 0x03, 0x02, 0x04, 0xc0, 0x90, 0x51, 0xa5, 0xe0, 0x78, 0x93, 0xf6, 0xa3, //0x8270,
	0xe0, 0x08, 0xf6, 0xa3, 0xe0, 0x08, 0xf6, 0xe5, 0x1f, 0x70, 0x3c, 0x75, 0x1e, 0x20, 0xd2, 0x35, //0x8280,
	0x12, 0x0c, 0x7a, 0x78, 0x7e, 0xa6, 0x06, 0x08, 0xa6, 0x07, 0x78, 0x8b, 0xa6, 0x09, 0x18, 0x76, //0x8290,
	0x01, 0x12, 0x0c, 0x5b, 0x78, 0x4e, 0xa6, 0x06, 0x08, 0xa6, 0x07, 0x78, 0x8b, 0xe6, 0x78, 0x6e, //0x82a0,
	0xf6, 0x75, 0x1f, 0x01, 0x78, 0x93, 0xe6, 0x78, 0x90, 0xf6, 0x78, 0x94, 0xe6, 0x78, 0x91, 0xf6, //0x82b0,
	0x78, 0x95, 0xe6, 0x78, 0x92, 0xf6, 0x22, 0x79, 0x90, 0xe7, 0xd3, 0x78, 0x93, 0x96, 0x40, 0x05, //0x82c0,
	0xe7, 0x96, 0xff, 0x80, 0x08, 0xc3, 0x79, 0x93, 0xe7, 0x78, 0x90, 0x96, 0xff, 0x78, 0x88, 0x76, //0x82d0,
	0x00, 0x08, 0xa6, 0x07, 0x79, 0x91, 0xe7, 0xd3, 0x78, 0x94, 0x96, 0x40, 0x05, 0xe7, 0x96, 0xff, //0x82e0,
	0x80, 0x08, 0xc3, 0x79, 0x94, 0xe7, 0x78, 0x91, 0x96, 0xff, 0x12, 0x0c, 0x8e, 0x79, 0x92, 0xe7, //0x82f0,
	0xd3, 0x78, 0x95, 0x96, 0x40, 0x05, 0xe7, 0x96, 0xff, 0x80, 0x08, 0xc3, 0x79, 0x95, 0xe7, 0x78, //0x8300,
	0x92, 0x96, 0xff, 0x12, 0x0c, 0x8e, 0x12, 0x0c, 0x5b, 0x78, 0x8a, 0xe6, 0x25, 0xe0, 0x24, 0x4e, //0x8310,
	0xf8, 0xa6, 0x06, 0x08, 0xa6, 0x07, 0x78, 0x8a, 0xe6, 0x24, 0x6e, 0xf8, 0xa6, 0x09, 0x78, 0x8a, //0x8320,
	0xe6, 0x24, 0x01, 0xff, 0xe4, 0x33, 0xfe, 0xd3, 0xef, 0x94, 0x0f, 0xee, 0x64, 0x80, 0x94, 0x80, //0x8330,
	0x40, 0x04, 0x7f, 0x00, 0x80, 0x05, 0x78, 0x8a, 0xe6, 0x04, 0xff, 0x78, 0x8a, 0xa6, 0x07, 0xe5, //0x8340,
	0x1f, 0xb4, 0x01, 0x0a, 0xe6, 0x60, 0x03, 0x02, 0x04, 0xc0, 0x75, 0x1f, 0x02, 0x22, 0x12, 0x0c, //0x8350,
	0x7a, 0x78, 0x80, 0xa6, 0x06, 0x08, 0xa6, 0x07, 0x12, 0x0c, 0x7a, 0x78, 0x82, 0xa6, 0x06, 0x08, //0x8360,
	0xa6, 0x07, 0x78, 0x6e, 0xe6, 0x78, 0x8c, 0xf6, 0x78, 0x6e, 0xe6, 0x78, 0x8d, 0xf6, 0x7f, 0x01, //0x8370,
	0xef, 0x25, 0xe0, 0x24, 0x4f, 0xf9, 0xc3, 0x78, 0x81, 0xe6, 0x97, 0x18, 0xe6, 0x19, 0x97, 0x50, //0x8380,
	0x0a, 0x12, 0x0c, 0x82, 0x78, 0x80, 0xa6, 0x04, 0x08, 0xa6, 0x05, 0x74, 0x6e, 0x2f, 0xf9, 0x78, //0x8390,
	0x8c, 0xe6, 0xc3, 0x97, 0x50, 0x08, 0x74, 0x6e, 0x2f, 0xf8, 0xe6, 0x78, 0x8c, 0xf6, 0xef, 0x25, //0x83a0,
	0xe0, 0x24, 0x4f, 0xf9, 0xd3, 0x78, 0x83, 0xe6, 0x97, 0x18, 0xe6, 0x19, 0x97, 0x40, 0x0a, 0x12, //0x83b0,
	0x0c, 0x82, 0x78, 0x82, 0xa6, 0x04, 0x08, 0xa6, 0x05, 0x74, 0x6e, 0x2f, 0xf9, 0x78, 0x8d, 0xe6, //0x83c0,
	0xd3, 0x97, 0x40, 0x08, 0x74, 0x6e, 0x2f, 0xf8, 0xe6, 0x78, 0x8d, 0xf6, 0x0f, 0xef, 0x64, 0x10, //0x83d0,
	0x70, 0x9e, 0xc3, 0x79, 0x81, 0xe7, 0x78, 0x83, 0x96, 0xff, 0x19, 0xe7, 0x18, 0x96, 0x78, 0x84, //0x83e0,
	0xf6, 0x08, 0xa6, 0x07, 0xc3, 0x79, 0x8c, 0xe7, 0x78, 0x8d, 0x96, 0x08, 0xf6, 0xd3, 0x79, 0x81, //0x83f0,
	0xe7, 0x78, 0x7f, 0x96, 0x19, 0xe7, 0x18, 0x96, 0x40, 0x05, 0x09, 0xe7, 0x08, 0x80, 0x06, 0xc3, //0x8400,
	0x79, 0x7f, 0xe7, 0x78, 0x81, 0x96, 0xff, 0x19, 0xe7, 0x18, 0x96, 0xfe, 0x78, 0x86, 0xa6, 0x06, //0x8410,
	0x08, 0xa6, 0x07, 0x79, 0x8c, 0xe7, 0xd3, 0x78, 0x8b, 0x96, 0x40, 0x05, 0xe7, 0x96, 0xff, 0x80, //0x8420,
	0x08, 0xc3, 0x79, 0x8b, 0xe7, 0x78, 0x8c, 0x96, 0xff, 0x78, 0x8f, 0xa6, 0x07, 0xe5, 0x1f, 0x64, //0x8430,
	0x02, 0x70, 0x69, 0x90, 0x0e, 0x91, 0x93, 0xff, 0x18, 0xe6, 0xc3, 0x9f, 0x50, 0x72, 0x12, 0x0c, //0x8440,
	0x4a, 0x12, 0x0c, 0x2f, 0x90, 0x0e, 0x8e, 0x12, 0x0c, 0x38, 0x78, 0x80, 0x12, 0x0c, 0x6b, 0x7b, //0x8450,
	0x04, 0x12, 0x0c, 0x1d, 0xc3, 0x12, 0x06, 0x45, 0x50, 0x56, 0x90, 0x0e, 0x92, 0xe4, 0x93, 0xff, //0x8460,
	0x78, 0x8f, 0xe6, 0x9f, 0x40, 0x02, 0x80, 0x11, 0x90, 0x0e, 0x90, 0xe4, 0x93, 0xff, 0xd3, 0x78, //0x8470,
	0x89, 0xe6, 0x9f, 0x18, 0xe6, 0x94, 0x00, 0x40, 0x03, 0x75, 0x1f, 0x05, 0x12, 0x0c, 0x4a, 0x12, //0x8480,
	0x0c, 0x2f, 0x90, 0x0e, 0x8f, 0x12, 0x0c, 0x38, 0x78, 0x7e, 0x12, 0x0c, 0x6b, 0x7b, 0x40, 0x12, //0x8490,
	0x0c, 0x1d, 0xd3, 0x12, 0x06, 0x45, 0x40, 0x18, 0x75, 0x1f, 0x05, 0x22, 0xe5, 0x1f, 0xb4, 0x05, //0x84a0,
	0x0f, 0xd2, 0x01, 0xc2, 0x02, 0xe4, 0xf5, 0x1f, 0xf5, 0x1e, 0xd2, 0x35, 0xd2, 0x33, 0xd2, 0x36, //0x84b0,
	0x22, 0xef, 0x8d, 0xf0, 0xa4, 0xa8, 0xf0, 0xcf, 0x8c, 0xf0, 0xa4, 0x28, 0xce, 0x8d, 0xf0, 0xa4, //0x84c0,
	0x2e, 0xfe, 0x22, 0xbc, 0x00, 0x0b, 0xbe, 0x00, 0x29, 0xef, 0x8d, 0xf0, 0x84, 0xff, 0xad, 0xf0, //0x84d0,
	0x22, 0xe4, 0xcc, 0xf8, 0x75, 0xf0, 0x08, 0xef, 0x2f, 0xff, 0xee, 0x33, 0xfe, 0xec, 0x33, 0xfc, //0x84e0,
	0xee, 0x9d, 0xec, 0x98, 0x40, 0x05, 0xfc, 0xee, 0x9d, 0xfe, 0x0f, 0xd5, 0xf0, 0xe9, 0xe4, 0xce, //0x84f0,
	0xfd, 0x22, 0xed, 0xf8, 0xf5, 0xf0, 0xee, 0x84, 0x20, 0xd2, 0x1c, 0xfe, 0xad, 0xf0, 0x75, 0xf0, //0x8500,
	0x08, 0xef, 0x2f, 0xff, 0xed, 0x33, 0xfd, 0x40, 0x07, 0x98, 0x50, 0x06, 0xd5, 0xf0, 0xf2, 0x22, //0x8510,
	0xc3, 0x98, 0xfd, 0x0f, 0xd5, 0xf0, 0xea, 0x22, 0xe8, 0x8f, 0xf0, 0xa4, 0xcc, 0x8b, 0xf0, 0xa4, //0x8520,
	0x2c, 0xfc, 0xe9, 0x8e, 0xf0, 0xa4, 0x2c, 0xfc, 0x8a, 0xf0, 0xed, 0xa4, 0x2c, 0xfc, 0xea, 0x8e, //0x8530,
	0xf0, 0xa4, 0xcd, 0xa8, 0xf0, 0x8b, 0xf0, 0xa4, 0x2d, 0xcc, 0x38, 0x25, 0xf0, 0xfd, 0xe9, 0x8f, //0x8540,
	0xf0, 0xa4, 0x2c, 0xcd, 0x35, 0xf0, 0xfc, 0xeb, 0x8e, 0xf0, 0xa4, 0xfe, 0xa9, 0xf0, 0xeb, 0x8f, //0x8550,
	0xf0, 0xa4, 0xcf, 0xc5, 0xf0, 0x2e, 0xcd, 0x39, 0xfe, 0xe4, 0x3c, 0xfc, 0xea, 0xa4, 0x2d, 0xce, //0x8560,
	0x35, 0xf0, 0xfd, 0xe4, 0x3c, 0xfc, 0x22, 0x75, 0xf0, 0x08, 0x75, 0x82, 0x00, 0xef, 0x2f, 0xff, //0x8570,
	0xee, 0x33, 0xfe, 0xcd, 0x33, 0xcd, 0xcc, 0x33, 0xcc, 0xc5, 0x82, 0x33, 0xc5, 0x82, 0x9b, 0xed, //0x8580,
	0x9a, 0xec, 0x99, 0xe5, 0x82, 0x98, 0x40, 0x0c, 0xf5, 0x82, 0xee, 0x9b, 0xfe, 0xed, 0x9a, 0xfd, //0x8590,
	0xec, 0x99, 0xfc, 0x0f, 0xd5, 0xf0, 0xd6, 0xe4, 0xce, 0xfb, 0xe4, 0xcd, 0xfa, 0xe4, 0xcc, 0xf9, //0x85a0,
	0xa8, 0x82, 0x22, 0xb8, 0x00, 0xc1, 0xb9, 0x00, 0x59, 0xba, 0x00, 0x2d, 0xec, 0x8b, 0xf0, 0x84, //0x85b0,
	0xcf, 0xce, 0xcd, 0xfc, 0xe5, 0xf0, 0xcb, 0xf9, 0x78, 0x18, 0xef, 0x2f, 0xff, 0xee, 0x33, 0xfe, //0x85c0,
	0xed, 0x33, 0xfd, 0xec, 0x33, 0xfc, 0xeb, 0x33, 0xfb, 0x10, 0xd7, 0x03, 0x99, 0x40, 0x04, 0xeb, //0x85d0,
	0x99, 0xfb, 0x0f, 0xd8, 0xe5, 0xe4, 0xf9, 0xfa, 0x22, 0x78, 0x18, 0xef, 0x2f, 0xff, 0xee, 0x33, //0x85e0,
	0xfe, 0xed, 0x33, 0xfd, 0xec, 0x33, 0xfc, 0xc9, 0x33, 0xc9, 0x10, 0xd7, 0x05, 0x9b, 0xe9, 0x9a, //0x85f0,
	0x40, 0x07, 0xec, 0x9b, 0xfc, 0xe9, 0x9a, 0xf9, 0x0f, 0xd8, 0xe0, 0xe4, 0xc9, 0xfa, 0xe4, 0xcc, //0x8600,
	0xfb, 0x22, 0x75, 0xf0, 0x10, 0xef, 0x2f, 0xff, 0xee, 0x33, 0xfe, 0xed, 0x33, 0xfd, 0xcc, 0x33, //0x8610,
	0xcc, 0xc8, 0x33, 0xc8, 0x10, 0xd7, 0x07, 0x9b, 0xec, 0x9a, 0xe8, 0x99, 0x40, 0x0a, 0xed, 0x9b, //0x8620,
	0xfd, 0xec, 0x9a, 0xfc, 0xe8, 0x99, 0xf8, 0x0f, 0xd5, 0xf0, 0xda, 0xe4, 0xcd, 0xfb, 0xe4, 0xcc, //0x8630,
	0xfa, 0xe4, 0xc8, 0xf9, 0x22, 0xeb, 0x9f, 0xf5, 0xf0, 0xea, 0x9e, 0x42, 0xf0, 0xe9, 0x9d, 0x42, //0x8640,
	0xf0, 0xe8, 0x9c, 0x45, 0xf0, 0x22, 0xe8, 0x60, 0x0f, 0xec, 0xc3, 0x13, 0xfc, 0xed, 0x13, 0xfd, //0x8650,
	0xee, 0x13, 0xfe, 0xef, 0x13, 0xff, 0xd8, 0xf1, 0x22, 0xe8, 0x60, 0x0f, 0xef, 0xc3, 0x33, 0xff, //0x8660,
	0xee, 0x33, 0xfe, 0xed, 0x33, 0xfd, 0xec, 0x33, 0xfc, 0xd8, 0xf1, 0x22, 0xe4, 0x93, 0xfc, 0x74, //0x8670,
	0x01, 0x93, 0xfd, 0x74, 0x02, 0x93, 0xfe, 0x74, 0x03, 0x93, 0xff, 0x22, 0xe6, 0xfb, 0x08, 0xe6, //0x8680,
	0xf9, 0x08, 0xe6, 0xfa, 0x08, 0xe6, 0xcb, 0xf8, 0x22, 0xec, 0xf6, 0x08, 0xed, 0xf6, 0x08, 0xee, //0x8690,
	0xf6, 0x08, 0xef, 0xf6, 0x22, 0xa4, 0x25, 0x82, 0xf5, 0x82, 0xe5, 0xf0, 0x35, 0x83, 0xf5, 0x83, //0x86a0,
	0x22, 0xd0, 0x83, 0xd0, 0x82, 0xf8, 0xe4, 0x93, 0x70, 0x12, 0x74, 0x01, 0x93, 0x70, 0x0d, 0xa3, //0x86b0,
	0xa3, 0x93, 0xf8, 0x74, 0x01, 0x93, 0xf5, 0x82, 0x88, 0x83, 0xe4, 0x73, 0x74, 0x02, 0x93, 0x68, //0x86c0,
	0x60, 0xef, 0xa3, 0xa3, 0xa3, 0x80, 0xdf, 0x90, 0x38, 0x04, 0x78, 0x52, 0x12, 0x0b, 0xfd, 0x90, //0x86d0,
	0x38, 0x00, 0xe0, 0xfe, 0xa3, 0xe0, 0xfd, 0xed, 0xff, 0xc3, 0x12, 0x0b, 0x9e, 0x90, 0x38, 0x10, //0x86e0,
	0x12, 0x0b, 0x92, 0x90, 0x38, 0x06, 0x78, 0x54, 0x12, 0x0b, 0xfd, 0x90, 0x38, 0x02, 0xe0, 0xfe, //0x86f0,
	0xa3, 0xe0, 0xfd, 0xed, 0xff, 0xc3, 0x12, 0x0b, 0x9e, 0x90, 0x38, 0x12, 0x12, 0x0b, 0x92, 0xa3, //0x8700,
	0xe0, 0xb4, 0x31, 0x07, 0x78, 0x52, 0x79, 0x52, 0x12, 0x0c, 0x13, 0x90, 0x38, 0x14, 0xe0, 0xb4, //0x8710,
	0x71, 0x15, 0x78, 0x52, 0xe6, 0xfe, 0x08, 0xe6, 0x78, 0x02, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, //0x8720,
	0xf9, 0x79, 0x53, 0xf7, 0xee, 0x19, 0xf7, 0x90, 0x38, 0x15, 0xe0, 0xb4, 0x31, 0x07, 0x78, 0x54, //0x8730,
	0x79, 0x54, 0x12, 0x0c, 0x13, 0x90, 0x38, 0x15, 0xe0, 0xb4, 0x71, 0x15, 0x78, 0x54, 0xe6, 0xfe, //0x8740,
	0x08, 0xe6, 0x78, 0x02, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x79, 0x55, 0xf7, 0xee, 0x19, //0x8750,
	0xf7, 0x79, 0x52, 0x12, 0x0b, 0xd9, 0x09, 0x12, 0x0b, 0xd9, 0xaf, 0x47, 0x12, 0x0b, 0xb2, 0xe5, //0x8760,
	0x44, 0xfb, 0x7a, 0x00, 0xfd, 0x7c, 0x00, 0x12, 0x04, 0xd3, 0x78, 0x5a, 0xa6, 0x06, 0x08, 0xa6, //0x8770,
	0x07, 0xaf, 0x45, 0x12, 0x0b, 0xb2, 0xad, 0x03, 0x7c, 0x00, 0x12, 0x04, 0xd3, 0x78, 0x56, 0xa6, //0x8780,
	0x06, 0x08, 0xa6, 0x07, 0xaf, 0x48, 0x78, 0x54, 0x12, 0x0b, 0xb4, 0xe5, 0x43, 0xfb, 0xfd, 0x7c, //0x8790,
	0x00, 0x12, 0x04, 0xd3, 0x78, 0x5c, 0xa6, 0x06, 0x08, 0xa6, 0x07, 0xaf, 0x46, 0x7e, 0x00, 0x78, //0x87a0,
	0x54, 0x12, 0x0b, 0xb6, 0xad, 0x03, 0x7c, 0x00, 0x12, 0x04, 0xd3, 0x78, 0x58, 0xa6, 0x06, 0x08, //0x87b0,
	0xa6, 0x07, 0xc3, 0x78, 0x5b, 0xe6, 0x94, 0x08, 0x18, 0xe6, 0x94, 0x00, 0x50, 0x05, 0x76, 0x00, //0x87c0,
	0x08, 0x76, 0x08, 0xc3, 0x78, 0x5d, 0xe6, 0x94, 0x08, 0x18, 0xe6, 0x94, 0x00, 0x50, 0x05, 0x76, //0x87d0,
	0x00, 0x08, 0x76, 0x08, 0x78, 0x5a, 0x12, 0x0b, 0xc6, 0xff, 0xd3, 0x78, 0x57, 0xe6, 0x9f, 0x18, //0x87e0,
	0xe6, 0x9e, 0x40, 0x0e, 0x78, 0x5a, 0xe6, 0x13, 0xfe, 0x08, 0xe6, 0x78, 0x57, 0x12, 0x0c, 0x08, //0x87f0,
	0x80, 0x04, 0x7e, 0x00, 0x7f, 0x00, 0x78, 0x5e, 0x12, 0x0b, 0xbe, 0xff, 0xd3, 0x78, 0x59, 0xe6, //0x8800,
	0x9f, 0x18, 0xe6, 0x9e, 0x40, 0x0e, 0x78, 0x5c, 0xe6, 0x13, 0xfe, 0x08, 0xe6, 0x78, 0x59, 0x12, //0x8810,
	0x0c, 0x08, 0x80, 0x04, 0x7e, 0x00, 0x7f, 0x00, 0xe4, 0xfc, 0xfd, 0x78, 0x62, 0x12, 0x06, 0x99, //0x8820,
	0x78, 0x5a, 0x12, 0x0b, 0xc6, 0x78, 0x57, 0x26, 0xff, 0xee, 0x18, 0x36, 0xfe, 0x78, 0x66, 0x12, //0x8830,
	0x0b, 0xbe, 0x78, 0x59, 0x26, 0xff, 0xee, 0x18, 0x36, 0xfe, 0xe4, 0xfc, 0xfd, 0x78, 0x6a, 0x12, //0x8840,
	0x06, 0x99, 0x12, 0x0b, 0xce, 0x78, 0x66, 0x12, 0x06, 0x8c, 0xd3, 0x12, 0x06, 0x45, 0x40, 0x08, //0x8850,
	0x12, 0x0b, 0xce, 0x78, 0x66, 0x12, 0x06, 0x99, 0x78, 0x54, 0x12, 0x0b, 0xd0, 0x78, 0x6a, 0x12, //0x8860,
	0x06, 0x8c, 0xd3, 0x12, 0x06, 0x45, 0x40, 0x0a, 0x78, 0x54, 0x12, 0x0b, 0xd0, 0x78, 0x6a, 0x12, //0x8870,
	0x06, 0x99, 0x78, 0x61, 0xe6, 0x90, 0x60, 0x01, 0xf0, 0x78, 0x65, 0xe6, 0xa3, 0xf0, 0x78, 0x69, //0x8880,
	0xe6, 0xa3, 0xf0, 0x78, 0x55, 0xe6, 0xa3, 0xf0, 0x7d, 0x01, 0x78, 0x61, 0x12, 0x0b, 0xe9, 0x24, //0x8890,
	0x01, 0x12, 0x0b, 0xa6, 0x78, 0x65, 0x12, 0x0b, 0xe9, 0x24, 0x02, 0x12, 0x0b, 0xa6, 0x78, 0x69, //0x88a0,
	0x12, 0x0b, 0xe9, 0x24, 0x03, 0x12, 0x0b, 0xa6, 0x78, 0x6d, 0x12, 0x0b, 0xe9, 0x24, 0x04, 0x12, //0x88b0,
	0x0b, 0xa6, 0x0d, 0xbd, 0x05, 0xd4, 0xc2, 0x0e, 0xc2, 0x06, 0x22, 0x85, 0x08, 0x41, 0x90, 0x30, //0x88c0,
	0x24, 0xe0, 0xf5, 0x3d, 0xa3, 0xe0, 0xf5, 0x3e, 0xa3, 0xe0, 0xf5, 0x3f, 0xa3, 0xe0, 0xf5, 0x40, //0x88d0,
	0xa3, 0xe0, 0xf5, 0x3c, 0xd2, 0x34, 0xe5, 0x41, 0x12, 0x06, 0xb1, 0x09, 0x31, 0x03, 0x09, 0x35, //0x88e0,
	0x04, 0x09, 0x3b, 0x05, 0x09, 0x3e, 0x06, 0x09, 0x41, 0x07, 0x09, 0x4a, 0x08, 0x09, 0x5b, 0x12, //0x88f0,
	0x09, 0x73, 0x18, 0x09, 0x89, 0x19, 0x09, 0x5e, 0x1a, 0x09, 0x6a, 0x1b, 0x09, 0xad, 0x80, 0x09, //0x8900,
	0xb2, 0x81, 0x0a, 0x1d, 0x8f, 0x0a, 0x09, 0x90, 0x0a, 0x1d, 0x91, 0x0a, 0x1d, 0x92, 0x0a, 0x1d, //0x8910,
	0x93, 0x0a, 0x1d, 0x94, 0x0a, 0x1d, 0x98, 0x0a, 0x17, 0x9f, 0x0a, 0x1a, 0xec, 0x00, 0x00, 0x0a, //0x8920,
	0x38, 0x12, 0x0f, 0x74, 0x22, 0x12, 0x0f, 0x74, 0xd2, 0x03, 0x22, 0xd2, 0x03, 0x22, 0xc2, 0x03, //0x8930,
	0x22, 0xa2, 0x37, 0xe4, 0x33, 0xf5, 0x3c, 0x02, 0x0a, 0x1d, 0xc2, 0x01, 0xc2, 0x02, 0xc2, 0x03, //0x8940,
	0x12, 0x0d, 0x0d, 0x75, 0x1e, 0x70, 0xd2, 0x35, 0x02, 0x0a, 0x1d, 0x02, 0x0a, 0x04, 0x85, 0x40, //0x8950,
	0x4a, 0x85, 0x3c, 0x4b, 0x12, 0x0a, 0xff, 0x02, 0x0a, 0x1d, 0x85, 0x4a, 0x40, 0x85, 0x4b, 0x3c, //0x8960,
	0x02, 0x0a, 0x1d, 0xe4, 0xf5, 0x22, 0xf5, 0x23, 0x85, 0x40, 0x31, 0x85, 0x3f, 0x30, 0x85, 0x3e, //0x8970,
	0x2f, 0x85, 0x3d, 0x2e, 0x12, 0x0f, 0x46, 0x80, 0x1f, 0x75, 0x22, 0x00, 0x75, 0x23, 0x01, 0x74, //0x8980,
	0xff, 0xf5, 0x2d, 0xf5, 0x2c, 0xf5, 0x2b, 0xf5, 0x2a, 0x12, 0x0f, 0x46, 0x85, 0x2d, 0x40, 0x85, //0x8990,
	0x2c, 0x3f, 0x85, 0x2b, 0x3e, 0x85, 0x2a, 0x3d, 0xe4, 0xf5, 0x3c, 0x80, 0x70, 0x12, 0x0f, 0x16, //0x89a0,
	0x80, 0x6b, 0x85, 0x3d, 0x45, 0x85, 0x3e, 0x46, 0xe5, 0x47, 0xc3, 0x13, 0xff, 0xe5, 0x45, 0xc3, //0x89b0,
	0x9f, 0x50, 0x02, 0x8f, 0x45, 0xe5, 0x48, 0xc3, 0x13, 0xff, 0xe5, 0x46, 0xc3, 0x9f, 0x50, 0x02, //0x89c0,
	0x8f, 0x46, 0xe5, 0x47, 0xc3, 0x13, 0xff, 0xfd, 0xe5, 0x45, 0x2d, 0xfd, 0xe4, 0x33, 0xfc, 0xe5, //0x89d0,
	0x44, 0x12, 0x0f, 0x90, 0x40, 0x05, 0xe5, 0x44, 0x9f, 0xf5, 0x45, 0xe5, 0x48, 0xc3, 0x13, 0xff, //0x89e0,
	0xfd, 0xe5, 0x46, 0x2d, 0xfd, 0xe4, 0x33, 0xfc, 0xe5, 0x43, 0x12, 0x0f, 0x90, 0x40, 0x05, 0xe5, //0x89f0,
	0x43, 0x9f, 0xf5, 0x46, 0x12, 0x06, 0xd7, 0x80, 0x14, 0x85, 0x40, 0x48, 0x85, 0x3f, 0x47, 0x85, //0x8a00,
	0x3e, 0x46, 0x85, 0x3d, 0x45, 0x80, 0x06, 0x02, 0x06, 0xd7, 0x12, 0x0d, 0x7e, 0x90, 0x30, 0x24, //0x8a10,
	0xe5, 0x3d, 0xf0, 0xa3, 0xe5, 0x3e, 0xf0, 0xa3, 0xe5, 0x3f, 0xf0, 0xa3, 0xe5, 0x40, 0xf0, 0xa3, //0x8a20,
	0xe5, 0x3c, 0xf0, 0x90, 0x30, 0x23, 0xe4, 0xf0, 0x22, 0xc0, 0xe0, 0xc0, 0x83, 0xc0, 0x82, 0xc0, //0x8a30,
	0xd0, 0x90, 0x3f, 0x0c, 0xe0, 0xf5, 0x32, 0xe5, 0x32, 0x30, 0xe3, 0x74, 0x30, 0x36, 0x66, 0x90, //0x8a40,
	0x60, 0x19, 0xe0, 0xf5, 0x0a, 0xa3, 0xe0, 0xf5, 0x0b, 0x90, 0x60, 0x1d, 0xe0, 0xf5, 0x14, 0xa3, //0x8a50,
	0xe0, 0xf5, 0x15, 0x90, 0x60, 0x21, 0xe0, 0xf5, 0x0c, 0xa3, 0xe0, 0xf5, 0x0d, 0x90, 0x60, 0x29, //0x8a60,
	0xe0, 0xf5, 0x0e, 0xa3, 0xe0, 0xf5, 0x0f, 0x90, 0x60, 0x31, 0xe0, 0xf5, 0x10, 0xa3, 0xe0, 0xf5, //0x8a70,
	0x11, 0x90, 0x60, 0x39, 0xe0, 0xf5, 0x12, 0xa3, 0xe0, 0xf5, 0x13, 0x30, 0x01, 0x06, 0x30, 0x33, //0x8a80,
	0x03, 0xd3, 0x80, 0x01, 0xc3, 0x92, 0x09, 0x30, 0x02, 0x06, 0x30, 0x33, 0x03, 0xd3, 0x80, 0x01, //0x8a90,
	0xc3, 0x92, 0x0a, 0x30, 0x33, 0x0c, 0x30, 0x03, 0x09, 0x20, 0x02, 0x06, 0x20, 0x01, 0x03, 0xd3, //0x8aa0,
	0x80, 0x01, 0xc3, 0x92, 0x0b, 0x90, 0x30, 0x01, 0xe0, 0x44, 0x40, 0xf0, 0xe0, 0x54, 0xbf, 0xf0, //0x8ab0,
	0xe5, 0x32, 0x30, 0xe1, 0x14, 0x30, 0x34, 0x11, 0x90, 0x30, 0x22, 0xe0, 0xf5, 0x08, 0xe4, 0xf0, //0x8ac0,
	0x30, 0x00, 0x03, 0xd3, 0x80, 0x01, 0xc3, 0x92, 0x08, 0xe5, 0x32, 0x30, 0xe5, 0x12, 0x90, 0x56, //0x8ad0,
	0xa1, 0xe0, 0xf5, 0x09, 0x30, 0x31, 0x09, 0x30, 0x05, 0x03, 0xd3, 0x80, 0x01, 0xc3, 0x92, 0x0d, //0x8ae0,
	0x90, 0x3f, 0x0c, 0xe5, 0x32, 0xf0, 0xd0, 0xd0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xe0, 0x32, 0x90, //0x8af0,
	0x0e, 0x7e, 0xe4, 0x93, 0xfe, 0x74, 0x01, 0x93, 0xff, 0xc3, 0x90, 0x0e, 0x7c, 0x74, 0x01, 0x93, //0x8b00,
	0x9f, 0xff, 0xe4, 0x93, 0x9e, 0xfe, 0xe4, 0x8f, 0x3b, 0x8e, 0x3a, 0xf5, 0x39, 0xf5, 0x38, 0xab, //0x8b10,
	0x3b, 0xaa, 0x3a, 0xa9, 0x39, 0xa8, 0x38, 0xaf, 0x4b, 0xfc, 0xfd, 0xfe, 0x12, 0x05, 0x28, 0x12, //0x8b20,
	0x0d, 0xe1, 0xe4, 0x7b, 0xff, 0xfa, 0xf9, 0xf8, 0x12, 0x05, 0xb3, 0x12, 0x0d, 0xe1, 0x90, 0x0e, //0x8b30,
	0x69, 0xe4, 0x12, 0x0d, 0xf6, 0x12, 0x0d, 0xe1, 0xe4, 0x85, 0x4a, 0x37, 0xf5, 0x36, 0xf5, 0x35, //0x8b40,
	0xf5, 0x34, 0xaf, 0x37, 0xae, 0x36, 0xad, 0x35, 0xac, 0x34, 0xa3, 0x12, 0x0d, 0xf6, 0x8f, 0x37, //0x8b50,
	0x8e, 0x36, 0x8d, 0x35, 0x8c, 0x34, 0xe5, 0x3b, 0x45, 0x37, 0xf5, 0x3b, 0xe5, 0x3a, 0x45, 0x36, //0x8b60,
	0xf5, 0x3a, 0xe5, 0x39, 0x45, 0x35, 0xf5, 0x39, 0xe5, 0x38, 0x45, 0x34, 0xf5, 0x38, 0xe4, 0xf5, //0x8b70,
	0x22, 0xf5, 0x23, 0x85, 0x3b, 0x31, 0x85, 0x3a, 0x30, 0x85, 0x39, 0x2f, 0x85, 0x38, 0x2e, 0x02, //0x8b80,
	0x0f, 0x46, 0xe0, 0xa3, 0xe0, 0x75, 0xf0, 0x02, 0xa4, 0xff, 0xae, 0xf0, 0xc3, 0x08, 0xe6, 0x9f, //0x8b90,
	0xf6, 0x18, 0xe6, 0x9e, 0xf6, 0x22, 0xff, 0xe5, 0xf0, 0x34, 0x60, 0x8f, 0x82, 0xf5, 0x83, 0xec, //0x8ba0,
	0xf0, 0x22, 0x78, 0x52, 0x7e, 0x00, 0xe6, 0xfc, 0x08, 0xe6, 0xfd, 0x02, 0x04, 0xc1, 0xe4, 0xfc, //0x8bb0,
	0xfd, 0x12, 0x06, 0x99, 0x78, 0x5c, 0xe6, 0xc3, 0x13, 0xfe, 0x08, 0xe6, 0x13, 0x22, 0x78, 0x52, //0x8bc0,
	0xe6, 0xfe, 0x08, 0xe6, 0xff, 0xe4, 0xfc, 0xfd, 0x22, 0xe7, 0xc4, 0xf8, 0x54, 0xf0, 0xc8, 0x68, //0x8bd0,
	0xf7, 0x09, 0xe7, 0xc4, 0x54, 0x0f, 0x48, 0xf7, 0x22, 0xe6, 0xfc, 0xed, 0x75, 0xf0, 0x04, 0xa4, //0x8be0,
	0x22, 0x12, 0x06, 0x7c, 0x8f, 0x48, 0x8e, 0x47, 0x8d, 0x46, 0x8c, 0x45, 0x22, 0xe0, 0xfe, 0xa3, //0x8bf0,
	0xe0, 0xfd, 0xee, 0xf6, 0xed, 0x08, 0xf6, 0x22, 0x13, 0xff, 0xc3, 0xe6, 0x9f, 0xff, 0x18, 0xe6, //0x8c00,
	0x9e, 0xfe, 0x22, 0xe6, 0xc3, 0x13, 0xf7, 0x08, 0xe6, 0x13, 0x09, 0xf7, 0x22, 0xad, 0x39, 0xac, //0x8c10,
	0x38, 0xfa, 0xf9, 0xf8, 0x12, 0x05, 0x28, 0x8f, 0x3b, 0x8e, 0x3a, 0x8d, 0x39, 0x8c, 0x38, 0xab, //0x8c20,
	0x37, 0xaa, 0x36, 0xa9, 0x35, 0xa8, 0x34, 0x22, 0x93, 0xff, 0xe4, 0xfc, 0xfd, 0xfe, 0x12, 0x05, //0x8c30,
	0x28, 0x8f, 0x37, 0x8e, 0x36, 0x8d, 0x35, 0x8c, 0x34, 0x22, 0x78, 0x84, 0xe6, 0xfe, 0x08, 0xe6, //0x8c40,
	0xff, 0xe4, 0x8f, 0x37, 0x8e, 0x36, 0xf5, 0x35, 0xf5, 0x34, 0x22, 0x90, 0x0e, 0x8c, 0xe4, 0x93, //0x8c50,
	0x25, 0xe0, 0x24, 0x0a, 0xf8, 0xe6, 0xfe, 0x08, 0xe6, 0xff, 0x22, 0xe6, 0xfe, 0x08, 0xe6, 0xff, //0x8c60,
	0xe4, 0x8f, 0x3b, 0x8e, 0x3a, 0xf5, 0x39, 0xf5, 0x38, 0x22, 0x78, 0x4e, 0xe6, 0xfe, 0x08, 0xe6, //0x8c70,
	0xff, 0x22, 0xef, 0x25, 0xe0, 0x24, 0x4e, 0xf8, 0xe6, 0xfc, 0x08, 0xe6, 0xfd, 0x22, 0x78, 0x89, //0x8c80,
	0xef, 0x26, 0xf6, 0x18, 0xe4, 0x36, 0xf6, 0x22, 0x75, 0x89, 0x03, 0x75, 0xa8, 0x01, 0x75, 0xb8, //0x8c90,
	0x04, 0x75, 0x34, 0xff, 0x75, 0x35, 0x0e, 0x75, 0x36, 0x15, 0x75, 0x37, 0x0d, 0x12, 0x0e, 0x9a, //0x8ca0,
	0x12, 0x00, 0x09, 0x12, 0x0f, 0x16, 0x12, 0x00, 0x06, 0xd2, 0x00, 0xd2, 0x34, 0xd2, 0xaf, 0x75, //0x8cb0,
	0x34, 0xff, 0x75, 0x35, 0x0e, 0x75, 0x36, 0x49, 0x75, 0x37, 0x03, 0x12, 0x0e, 0x9a, 0x30, 0x08, //0x8cc0,
	0x09, 0xc2, 0x34, 0x12, 0x08, 0xcb, 0xc2, 0x08, 0xd2, 0x34, 0x30, 0x0b, 0x09, 0xc2, 0x36, 0x12, //0x8cd0,
	0x02, 0x6c, 0xc2, 0x0b, 0xd2, 0x36, 0x30, 0x09, 0x09, 0xc2, 0x36, 0x12, 0x00, 0x0e, 0xc2, 0x09, //0x8ce0,
	0xd2, 0x36, 0x30, 0x0e, 0x03, 0x12, 0x06, 0xd7, 0x30, 0x35, 0xd3, 0x90, 0x30, 0x29, 0xe5, 0x1e, //0x8cf0,
	0xf0, 0xb4, 0x10, 0x05, 0x90, 0x30, 0x23, 0xe4, 0xf0, 0xc2, 0x35, 0x80, 0xc1, 0xe4, 0xf5, 0x4b, //0x8d00,
	0x90, 0x0e, 0x7a, 0x93, 0xff, 0xe4, 0x8f, 0x37, 0xf5, 0x36, 0xf5, 0x35, 0xf5, 0x34, 0xaf, 0x37, //0x8d10,
	0xae, 0x36, 0xad, 0x35, 0xac, 0x34, 0x90, 0x0e, 0x6a, 0x12, 0x0d, 0xf6, 0x8f, 0x37, 0x8e, 0x36, //0x8d20,
	0x8d, 0x35, 0x8c, 0x34, 0x90, 0x0e, 0x72, 0x12, 0x06, 0x7c, 0xef, 0x45, 0x37, 0xf5, 0x37, 0xee, //0x8d30,
	0x45, 0x36, 0xf5, 0x36, 0xed, 0x45, 0x35, 0xf5, 0x35, 0xec, 0x45, 0x34, 0xf5, 0x34, 0xe4, 0xf5, //0x8d40,
	0x22, 0xf5, 0x23, 0x85, 0x37, 0x31, 0x85, 0x36, 0x30, 0x85, 0x35, 0x2f, 0x85, 0x34, 0x2e, 0x12, //0x8d50,
	0x0f, 0x46, 0xe4, 0xf5, 0x22, 0xf5, 0x23, 0x90, 0x0e, 0x72, 0x12, 0x0d, 0xea, 0x12, 0x0f, 0x46, //0x8d60,
	0xe4, 0xf5, 0x22, 0xf5, 0x23, 0x90, 0x0e, 0x6e, 0x12, 0x0d, 0xea, 0x02, 0x0f, 0x46, 0xe5, 0x40, //0x8d70,
	0x24, 0xf2, 0xf5, 0x37, 0xe5, 0x3f, 0x34, 0x43, 0xf5, 0x36, 0xe5, 0x3e, 0x34, 0xa2, 0xf5, 0x35, //0x8d80,
	0xe5, 0x3d, 0x34, 0x28, 0xf5, 0x34, 0xe5, 0x37, 0xff, 0xe4, 0xfe, 0xfd, 0xfc, 0x78, 0x18, 0x12, //0x8d90,
	0x06, 0x69, 0x8f, 0x40, 0x8e, 0x3f, 0x8d, 0x3e, 0x8c, 0x3d, 0xe5, 0x37, 0x54, 0xa0, 0xff, 0xe5, //0x8da0,
	0x36, 0xfe, 0xe4, 0xfd, 0xfc, 0x78, 0x07, 0x12, 0x06, 0x56, 0x78, 0x10, 0x12, 0x0f, 0x9a, 0xe4, //0x8db0,
	0xff, 0xfe, 0xe5, 0x35, 0xfd, 0xe4, 0xfc, 0x78, 0x0e, 0x12, 0x06, 0x56, 0x12, 0x0f, 0x9d, 0xe4, //0x8dc0,
	0xff, 0xfe, 0xfd, 0xe5, 0x34, 0xfc, 0x78, 0x18, 0x12, 0x06, 0x56, 0x78, 0x08, 0x12, 0x0f, 0x9a, //0x8dd0,
	0x22, 0x8f, 0x3b, 0x8e, 0x3a, 0x8d, 0x39, 0x8c, 0x38, 0x22, 0x12, 0x06, 0x7c, 0x8f, 0x31, 0x8e, //0x8de0,
	0x30, 0x8d, 0x2f, 0x8c, 0x2e, 0x22, 0x93, 0xf9, 0xf8, 0x02, 0x06, 0x69, 0x00, 0x00, 0x00, 0x00, //0x8df0,
	0x12, 0x01, 0x17, 0x08, 0x31, 0x15, 0x53, 0x54, 0x44, 0x20, 0x20, 0x20, 0x20, 0x20, 0x13, 0x01, //0x8e00,
	0x10, 0x01, 0x56, 0x40, 0x1a, 0x30, 0x29, 0x7e, 0x00, 0x30, 0x04, 0x20, 0xdf, 0x30, 0x05, 0x40, //0x8e10,
	0xbf, 0x50, 0x03, 0x00, 0xfd, 0x50, 0x27, 0x01, 0xfe, 0x60, 0x00, 0x11, 0x00, 0x3f, 0x05, 0x30, //0x8e20,
	0x00, 0x3f, 0x06, 0x22, 0x00, 0x3f, 0x01, 0x2a, 0x00, 0x3f, 0x02, 0x00, 0x00, 0x36, 0x06, 0x07, //0x8e30,
	0x00, 0x3f, 0x0b, 0x0f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x30, 0x01, 0x40, 0xbf, 0x30, 0x01, 0x00, //0x8e40,
	0xbf, 0x30, 0x29, 0x70, 0x00, 0x3a, 0x00, 0x00, 0xff, 0x3a, 0x00, 0x00, 0xff, 0x36, 0x03, 0x36, //0x8e50,
	0x02, 0x41, 0x44, 0x58, 0x20, 0x18, 0x10, 0x0a, 0x04, 0x04, 0x00, 0x03, 0xff, 0x64, 0x00, 0x00, //0x8e60,
	0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x06, 0x06, 0x00, 0x03, 0x51, 0x00, 0x7a, //0x8e70,
	0x50, 0x3c, 0x28, 0x1e, 0x10, 0x10, 0x50, 0x2d, 0x28, 0x16, 0x10, 0x10, 0x02, 0x00, 0x10, 0x0c, //0x8e80,
	0x10, 0x04, 0x0c, 0x6e, 0x06, 0x05, 0x00, 0xa5, 0x5a, 0x00, 0xae, 0x35, 0xaf, 0x36, 0xe4, 0xfd, //0x8e90,
	0xed, 0xc3, 0x95, 0x37, 0x50, 0x33, 0x12, 0x0f, 0xe2, 0xe4, 0x93, 0xf5, 0x38, 0x74, 0x01, 0x93, //0x8ea0,
	0xf5, 0x39, 0x45, 0x38, 0x60, 0x23, 0x85, 0x39, 0x82, 0x85, 0x38, 0x83, 0xe0, 0xfc, 0x12, 0x0f, //0x8eb0,
	0xe2, 0x74, 0x03, 0x93, 0x52, 0x04, 0x12, 0x0f, 0xe2, 0x74, 0x02, 0x93, 0x42, 0x04, 0x85, 0x39, //0x8ec0,
	0x82, 0x85, 0x38, 0x83, 0xec, 0xf0, 0x0d, 0x80, 0xc7, 0x22, 0x78, 0xbe, 0xe6, 0xd3, 0x08, 0xff, //0x8ed0,
	0xe6, 0x64, 0x80, 0xf8, 0xef, 0x64, 0x80, 0x98, 0x22, 0x93, 0xff, 0x7e, 0x00, 0xe6, 0xfc, 0x08, //0x8ee0,
	0xe6, 0xfd, 0x12, 0x04, 0xc1, 0x78, 0xc1, 0xe6, 0xfc, 0x08, 0xe6, 0xfd, 0xd3, 0xef, 0x9d, 0xee, //0x8ef0,
	0x9c, 0x22, 0x78, 0xbd, 0xd3, 0xe6, 0x64, 0x80, 0x94, 0x80, 0x22, 0x25, 0xe0, 0x24, 0x0a, 0xf8, //0x8f00,
	0xe6, 0xfe, 0x08, 0xe6, 0xff, 0x22, 0xe5, 0x3c, 0xd3, 0x94, 0x00, 0x40, 0x0b, 0x90, 0x0e, 0x88, //0x8f10,
	0x12, 0x0b, 0xf1, 0x90, 0x0e, 0x86, 0x80, 0x09, 0x90, 0x0e, 0x82, 0x12, 0x0b, 0xf1, 0x90, 0x0e, //0x8f20,
	0x80, 0xe4, 0x93, 0xf5, 0x44, 0xa3, 0xe4, 0x93, 0xf5, 0x43, 0xd2, 0x06, 0x30, 0x06, 0x03, 0xd3, //0x8f30,
	0x80, 0x01, 0xc3, 0x92, 0x0e, 0x22, 0xa2, 0xaf, 0x92, 0x32, 0xc2, 0xaf, 0xe5, 0x23, 0x45, 0x22, //0x8f40,
	0x90, 0x0e, 0x5d, 0x60, 0x0e, 0x12, 0x0f, 0xcb, 0xe0, 0xf5, 0x2c, 0x12, 0x0f, 0xc8, 0xe0, 0xf5, //0x8f50,
	0x2d, 0x80, 0x0c, 0x12, 0x0f, 0xcb, 0xe5, 0x30, 0xf0, 0x12, 0x0f, 0xc8, 0xe5, 0x31, 0xf0, 0xa2, //0x8f60,
	0x32, 0x92, 0xaf, 0x22, 0xd2, 0x01, 0xc2, 0x02, 0xe4, 0xf5, 0x1f, 0xf5, 0x1e, 0xd2, 0x35, 0xd2, //0x8f70,
	0x33, 0xd2, 0x36, 0xd2, 0x01, 0xc2, 0x02, 0xf5, 0x1f, 0xf5, 0x1e, 0xd2, 0x35, 0xd2, 0x33, 0x22, //0x8f80,
	0xfb, 0xd3, 0xed, 0x9b, 0x74, 0x80, 0xf8, 0x6c, 0x98, 0x22, 0x12, 0x06, 0x69, 0xe5, 0x40, 0x2f, //0x8f90,
	0xf5, 0x40, 0xe5, 0x3f, 0x3e, 0xf5, 0x3f, 0xe5, 0x3e, 0x3d, 0xf5, 0x3e, 0xe5, 0x3d, 0x3c, 0xf5, //0x8fa0,
	0x3d, 0x22, 0xc0, 0xe0, 0xc0, 0x83, 0xc0, 0x82, 0x90, 0x3f, 0x0d, 0xe0, 0xf5, 0x33, 0xe5, 0x33, //0x8fb0,
	0xf0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xe0, 0x32, 0x90, 0x0e, 0x5f, 0xe4, 0x93, 0xfe, 0x74, 0x01, //0x8fc0,
	0x93, 0xf5, 0x82, 0x8e, 0x83, 0x22, 0x78, 0x7f, 0xe4, 0xf6, 0xd8, 0xfd, 0x75, 0x81, 0xcd, 0x02, //0x8fd0,
	0x0c, 0x98, 0x8f, 0x82, 0x8e, 0x83, 0x75, 0xf0, 0x04, 0xed, 0x02, 0x06, 0xa5, //0x8fe0
};


/*
 * The white balance settings
 * Here only tune the R G B channel gain.
 * The white balance enalbe bit is modified in sensor_s_autowb and sensor_s_wb
 */
static struct regval_list sensor_wb_auto_regs[] = {
	{0x01A0,0x01},
};

static struct regval_list sensor_wb_cloud_regs[] = {
	{0x01A0,0x03},//MWB
	{0x01A1,0x62},
	{0x01A2,0x08},
	{0x01A3,0x00},
};

static struct regval_list sensor_wb_daylight_regs[] = {
	{0x01A0,0x03},//MWB
	{0x01A1,0x4f},
	{0x01A2,0x00},
	{0x01A3,0x01},
};

static struct regval_list sensor_wb_incandescence_regs[] = {
	{0x01A0,0x03},//MWB
	{0x01A1,0x10},
	{0x01A2,0x00},
	{0x01A3,0x52},
};

static struct regval_list sensor_wb_fluorescent_regs[] = {
	{0x01A0,0x03},//MWB
	{0x01A1,0x39},
	{0x01A2,0x00},
	{0x01A3,0x59},
};

static struct regval_list sensor_wb_tungsten_regs[] = {
	{0x01A0,0x03},//MWB
	{0x01A1,0x05},
	{0x01A2,0x00},
	{0x01A3,0x7f},
};

/*
 * The color effect settings
 */
static struct regval_list sensor_colorfx_none_regs[] = {
	{0x0380,0x00},
	{0x0381,0x00},
	{0x0382,0x00},
	{0x0384,0x00},
};

static struct regval_list sensor_colorfx_bw_regs[] = {
	{0x0380,0x00},
	{0x0381,0x00},
	{0x0382,0x00},
	{0x0384,0x05},
};

static struct regval_list sensor_colorfx_sepia_regs[] = {
	{0x0380,0x00},
	{0x0381,0x00},
	{0x0382,0x00},
	{0x0384,0x06},
};

static struct regval_list sensor_colorfx_negative_regs[] = {
	{0x0380,0x01},
	{0x0381,0x00},
	{0x0382,0x00},
	{0x0384,0x00},
};

static struct regval_list sensor_colorfx_emboss_regs[] = {

};

static struct regval_list sensor_colorfx_sketch_regs[] = {

};

static struct regval_list sensor_colorfx_sky_blue_regs[] = {
	{0x0380,0x00},
	{0x0381,0x00},
	{0x0382,0x00},
	{0x0384,0x04},
};

static struct regval_list sensor_colorfx_grass_green_regs[] = {
	{0x0380,0x00},
	{0x0381,0x00},
	{0x0382,0x00},
	{0x0384,0x03},
};

static struct regval_list sensor_colorfx_skin_whiten_regs[] = {
//NULL
};

static struct regval_list sensor_colorfx_vivid_regs[] = {
//NULL
};

/*
 * The brightness setttings
 */
static struct regval_list sensor_brightness_neg4_regs[] = {
//NULL
};

static struct regval_list sensor_brightness_neg3_regs[] = {
//NULL
};

static struct regval_list sensor_brightness_neg2_regs[] = {
//NULL
};

static struct regval_list sensor_brightness_neg1_regs[] = {
//NULL
};

static struct regval_list sensor_brightness_zero_regs[] = {
//NULL
};

static struct regval_list sensor_brightness_pos1_regs[] = {
//NULL
};

static struct regval_list sensor_brightness_pos2_regs[] = {
//NULL
};

static struct regval_list sensor_brightness_pos3_regs[] = {
//NULL
};

static struct regval_list sensor_brightness_pos4_regs[] = {
//NULL
};

/*
 * The contrast setttings
 */
static struct regval_list sensor_contrast_neg4_regs[] = {
//NULL
};

static struct regval_list sensor_contrast_neg3_regs[] = {
//NULL
};

static struct regval_list sensor_contrast_neg2_regs[] = {
//NULL
};

static struct regval_list sensor_contrast_neg1_regs[] = {
//NULL
};

static struct regval_list sensor_contrast_zero_regs[] = {
//NULL
};

static struct regval_list sensor_contrast_pos1_regs[] = {
//NULL
};

static struct regval_list sensor_contrast_pos2_regs[] = {
//NULL
};

static struct regval_list sensor_contrast_pos3_regs[] = {
//NULL
};

static struct regval_list sensor_contrast_pos4_regs[] = {
//NULL
};

/*
 * The saturation setttings
 */
static struct regval_list sensor_saturation_neg4_regs[] = {
//NULL
};

static struct regval_list sensor_saturation_neg3_regs[] = {
//NULL
};

static struct regval_list sensor_saturation_neg2_regs[] = {
//NULL
};

static struct regval_list sensor_saturation_neg1_regs[] = {
//NULL
};

static struct regval_list sensor_saturation_zero_regs[] = {
//NULL
};

static struct regval_list sensor_saturation_pos1_regs[] = {
//NULL
};

static struct regval_list sensor_saturation_pos2_regs[] = {
//NULL
};

static struct regval_list sensor_saturation_pos3_regs[] = {
//NULL
};

static struct regval_list sensor_saturation_pos4_regs[] = {
//NULL
};

/*
 * The exposure target setttings
 */

static struct regval_list sensor_ev_neg4_regs[] = {
	{0x0130,0xf6},//-1.3EV
};

static struct regval_list sensor_ev_neg3_regs[] = {
	{0x0130,0xf7},	//-1.0EV
};

static struct regval_list sensor_ev_neg2_regs[] = {
	{0x0130,0xf8},	//-0.7EV
};

static struct regval_list sensor_ev_neg1_regs[] = {
	{0x0130,0xf9},	//-0.3EV
};

static struct regval_list sensor_ev_zero_regs[] = {
	{0x0130,0xfd},		//default
};

static struct regval_list sensor_ev_pos1_regs[] = {
	{0x0130,0x03},	//0.3EV
};

static struct regval_list sensor_ev_pos2_regs[] = {
	{0x0130,0x05},	//0.7EV
};

static struct regval_list sensor_ev_pos3_regs[] = {
	{0x0130,0x06},	//1.0EV
};

static struct regval_list sensor_ev_pos4_regs[] = {
	{0x0130,0x07},	//1.3EV
};


/*
 * Here we'll try to encapsulate the changes for just the output
 * video format.
 *
 */


static struct regval_list sensor_fmt_yuv422_yuyv[] = {
	{0x0085,0x02},	//YUYV
};


static struct regval_list sensor_fmt_yuv422_yvyu[] = {
	{0x0085,0x03},	//YVYU
};

static struct regval_list sensor_fmt_yuv422_vyuy[] = {
	{0x0085,0x01},	//VYUY
};

static struct regval_list sensor_fmt_yuv422_uyvy[] = {
	{0x0085,0x00},	//UYVY
};

/*
 * Write a list of continuous register setting;
 */
static int sensor_write_continuous(struct v4l2_subdev *sd, unsigned short addr, unsigned char vals[] , uint size)
{
	struct i2c_client *client = v4l2_get_subdevdata(sd);
	struct i2c_msg msg;
	unsigned char data[2+32];
	unsigned char *p = vals;
	int ret,i;

	while (size > 0) {
		int len = size > 32 ? 32 : size;
		data[0] = (addr&0xff00) >> 8;
		data[1] = (addr&0x00ff);

		for(i = 2; i < 2+len; i++)
			data[i] = *p++;

		msg.addr = client->addr;
		msg.flags = 0;
		msg.len = 2+len;
		msg.buf = data;

		ret = i2c_transfer(client->adapter, &msg, 1);

		if (ret > 0) {
			ret = 0;
		} else if (ret < 0) {
			vfe_dev_err("sensor_write error!\n");
		}
		addr += len;
		size -= len;
	}
	return ret;
}

/* stuff about auto focus */

static int sensor_download_af_fw(struct v4l2_subdev *sd)
{
	int ret,cnt;
	data_type rdval;
	struct regval_list af_fw_reset_reg[] = {
		{0x3000,0x20},
	};
	struct regval_list af_fw_start_reg[] = {
		{0x3022,0x00},
		{0x3023,0x00},
		{0x3024,0x00},
		{0x3025,0x00},
		{0x3026,0x00},
		{0x3027,0x00},
		{0x3028,0x00},
		{0x3029,0x7f},
		{0x3000,0x00},	//start firmware for af
	};
	return 0;//gong
	//reset sensor MCU
	ret = sensor_write_array(sd, af_fw_reset_reg, ARRAY_SIZE(af_fw_reset_reg));
	if(ret < 0) {
		 vfe_dev_err("reset sensor MCU error\n");
		return ret;
	}

	//download af fw
	ret =sensor_write_continuous(sd, 0x8000, sensor_af_fw_regs, ARRAY_SIZE(sensor_af_fw_regs));
	if(ret < 0) {
		 vfe_dev_err("download af fw error\n");
		return ret;
	}
	//start af firmware
	ret = sensor_write_array(sd, af_fw_start_reg, ARRAY_SIZE(af_fw_start_reg));
	if(ret < 0) {
		 vfe_dev_err("start af firmware error\n");
		return ret;
	}

	mdelay(10);
	//check the af firmware status
	rdval = 0xff;
	cnt = 0;
	while(rdval!=0x70) {
		mdelay(5);
		ret = sensor_read(sd, 0x3029, &rdval);
		if (ret < 0)
		{
			 vfe_dev_err("sensor check the af firmware status err !\n");
			return ret;
		}
		cnt++;
		if(cnt > 200) {
			 vfe_dev_err("AF firmware check status time out !\n");
			return -EFAULT;
		}
	}
	vfe_dev_print("AF firmware check status complete,0x3029 = 0x%x\n",rdval);

#if DEV_DBG_EN == 1
	sensor_read(sd, 0x3000, &rdval);
	vfe_dev_print("0x3000 = 0x%x\n",rdval);

	sensor_read(sd, 0x3004, &rdval);
	vfe_dev_print("0x3004 = 0x%x\n",rdval);

	sensor_read(sd, 0x3001, &rdval);
	vfe_dev_print("0x3001 = 0x%x\n",rdval);

	sensor_read(sd, 0x3005, &rdval);
	vfe_dev_print("0x3005 = 0x%x\n",rdval);
#endif

  return 0;
}

static int sensor_g_single_af(struct v4l2_subdev *sd)
{
	data_type rdval;
	int ret;
	//vfe_dev_dbg("sensor_g_single_af\n");

	rdval = 0xff;

	ret = sensor_read(sd, 0x07ae, &rdval);
	if (ret < 0)
	{
		vfe_dev_err("sensor get af focused status err !\n");
		return ret;
	}

	if(rdval == 1)
	{
		return V4L2_AUTO_FOCUS_STATUS_REACHED;
	}

	return V4L2_AUTO_FOCUS_STATUS_FAILED;
}

static int sensor_g_contin_af(struct v4l2_subdev *sd)
{
	data_type rdval;
	struct sensor_info *info = to_state(sd);

	vfe_dev_dbg("sensor_g_contin_af\n");

	rdval = 0xff;


    info->focus_status = 0; //idle
    sensor_read(sd, 0x07AE, &rdval);
    if(rdval==0)
    {
	    return V4L2_AUTO_FOCUS_STATUS_FAILED;
    }
    else
    {
		return V4L2_AUTO_FOCUS_STATUS_REACHED;
    }

}

static int sensor_g_af_status(struct v4l2_subdev *sd)
{
	int ret=0;
	struct sensor_info *info = to_state(sd);

	if(info->auto_focus==1)
		ret = sensor_g_contin_af(sd);
	else
		ret = sensor_g_single_af(sd);

	return ret;
}

static int sensor_g_3a_lock(struct v4l2_subdev *sd)
{
	struct sensor_info *info = to_state(sd);
	return ( (info->auto_focus==0)?V4L2_LOCK_FOCUS:~V4L2_LOCK_FOCUS |
	       (info->autowb==0)?V4L2_LOCK_WHITE_BALANCE:~V4L2_LOCK_WHITE_BALANCE |
	       (~V4L2_LOCK_EXPOSURE)
	     );
}

static int sensor_s_init_af(struct v4l2_subdev *sd)
{
	int ret;
	struct sensor_info *info = to_state(sd);
	ret=sensor_download_af_fw(sd);
	if(ret==0)
		info->af_first_flag=0;
	//other config
	return ret;
}

static int sensor_s_single_af(struct v4l2_subdev *sd)
{
	int ret;
	single_af = true;
	vfe_dev_print("sensor_s_single_af\n");
	mdelay(100);
	ret = sensor_write(sd, 0x070a, 0x03);
	mdelay(100);
	ret = sensor_write(sd, 0x070b, 0x01);
	ret = sensor_write(sd,0x070b, 0x02);

	return 0;
}

static int sensor_g_autofocus_ctrl(struct v4l2_subdev *sd,
		struct v4l2_control *ctrl);

static int sensor_s_continueous_af(struct v4l2_subdev *sd)
{
	int ret;
	vfe_dev_print("sensor_s_continueous_af\n");
	ret = sensor_write(sd, 0x070a, 0x01);
	if (ret < 0)
	{
		vfe_dev_err("sensor tigger continueous af err !\n");
		return ret;
	}
	return 0;
}

static int sensor_s_pause_af(struct v4l2_subdev *sd)
{
	int ret;
	//pause af poisition
	return 0;//gong
	vfe_dev_print("sensor_s_pause_af\n");
	ret = sensor_write(sd, 0x3022, 0x06);
	if (ret < 0)
	{
		vfe_dev_err("sensor pause af err !\n");
		return ret;
	}
	mdelay(5);
	return 0;
}

static int sensor_s_release_af(struct v4l2_subdev *sd)
{
	int ret;
	vfe_dev_print("sensor_s_release_af\n");
	ret = sensor_write(sd, 0x070a, 0x00);
	if (ret < 0)
	{
		vfe_dev_err("sensor tigger single af err !\n");
		return ret;
	}
	//release single af
	ret = sensor_write(sd, 0x070c, 0x00);
	if (ret < 0)
	{
		 vfe_dev_err("release focus err !\n");
		return ret;
	}
	ret = sensor_write(sd, 0x070c, 0x03);
	if (ret < 0)
	{
		 vfe_dev_err("release focus err !\n");
		return ret;
	}
	return 0;
}

static int sensor_s_af_zone(struct v4l2_subdev *sd, unsigned int xc, unsigned int yc)
{
	struct sensor_info *info = to_state(sd);
	int ret;

	vfe_dev_print("sensor_s_af_zone\n");
	vfe_dev_dbg("af zone input xc=%d,yc=%d\n",xc,yc);
	return 0;//gong
	if(info->width == 0 || info->height == 0) {
		vfe_dev_err("current width or height is zero!\n");
		return -EINVAL;
	}

	xc = xc * 80 / info->width;
	if((info->width == HD720_WIDTH && info->height == HD720_HEIGHT) || \
			(info->width == HD1080_WIDTH && info->height == HD1080_HEIGHT)) {
		yc = yc * 45 / info->height;
	} else {
		yc = yc * 60 / info->height;
	}

	vfe_dev_dbg("af zone after xc=%d,yc=%d\n",xc,yc);

	//set x center
	ret = sensor_write(sd,0x3024, xc);
	if (ret < 0)
	{
		vfe_dev_err("sensor_s_af_zone_xc error!\n");
		return ret;
	}
	//set y center
	ret = sensor_write(sd, 0x3025, yc);
	if (ret < 0)
	{
		vfe_dev_err("sensor_s_af_zone_yc error!\n");
		return ret;
	}

	//set af zone
	ret = sensor_write(sd, 0x3022, 0x81);
	if (ret < 0)
	{
		vfe_dev_err("sensor_s_af_zone error!\n");
		return ret;
	}
	mdelay(5);
	return 0;
}


/* *********************************************begin of ******************************************** */


static int sensor_g_hflip(struct v4l2_subdev *sd, __s32 *value)
{
	struct sensor_info *info = to_state(sd);
	data_type rdval;

	LOG_ERR_RET(sensor_read(sd, 0x0083, &rdval))
	rdval&= 0x01;

	*value = rdval;

	info->hflip = *value;
	return 0;
}

static int sensor_s_hflip(struct v4l2_subdev *sd, int value)
{
	struct sensor_info *info = to_state(sd);
	data_type rdval;

	if(info->hflip == value)
  		  return 0;
	LOG_ERR_RET(sensor_read(sd, 0x0083, &rdval))


	switch (value) {
	case 0:
		rdval &= 0xfe;
		break;
	case 1:
		rdval |= 0x01;
		break;
	default:
		return -EINVAL;
	}

	LOG_ERR_RET(sensor_write(sd, 0x0083, rdval))

	mdelay(10);

	info->hflip = value;

	return 0;

}

static int sensor_g_vflip(struct v4l2_subdev *sd, __s32 *value)
{
	struct sensor_info *info = to_state(sd);
	data_type rdval;

	LOG_ERR_RET(sensor_read(sd, 0x0084, &rdval))


	rdval &= 0x01;

	*value = rdval;

	info->vflip = *value;

	return 0;
}

static int sensor_s_vflip(struct v4l2_subdev *sd, int value)
{
	struct sensor_info *info = to_state(sd);
	data_type rdval;

	if(info->vflip == value)
		return 0;

	LOG_ERR_RET(sensor_read(sd, 0x0084, &rdval))

	switch (value) {
		case 0:
		 	 rdval &= 0xfe;
			break;
		case 1:
			rdval |= 0x01;
			break;
		default:
			return -EINVAL;
	}

  	LOG_ERR_RET(sensor_write(sd, 0x0084, rdval))

  	mdelay(10);
  	info->vflip = value;
  	return 0;
}


static int sensor_g_autogain(struct v4l2_subdev *sd, __s32 *value)
{
	return -EINVAL;
}

static int sensor_s_autogain(struct v4l2_subdev *sd, int value)
{
	return -EINVAL;
}


static int sensor_g_exp(struct v4l2_subdev *sd, __s32 *value)
{
	struct sensor_info *info = to_state(sd);

	*value = info->exp;
	return 0;
}

static int sensor_s_exp(struct v4l2_subdev *sd, int value)
{
	int ret;
	struct sensor_info *info = to_state(sd);

	switch (value) {
		case -4:
		  ret = sensor_write_array(sd, sensor_ev_neg4_regs, ARRAY_SIZE(sensor_ev_neg4_regs));
			break;
		case -3:
			ret = sensor_write_array(sd, sensor_ev_neg3_regs, ARRAY_SIZE(sensor_ev_neg3_regs));
			break;
		case -2:
			ret = sensor_write_array(sd, sensor_ev_neg2_regs, ARRAY_SIZE(sensor_ev_neg2_regs));
			break;
		case -1:
			ret = sensor_write_array(sd, sensor_ev_neg1_regs, ARRAY_SIZE(sensor_ev_neg1_regs));
			break;
		case 0:
			ret = sensor_write_array(sd, sensor_ev_zero_regs, ARRAY_SIZE(sensor_ev_zero_regs));
			break;
		case 1:
			ret = sensor_write_array(sd, sensor_ev_pos1_regs, ARRAY_SIZE(sensor_ev_pos1_regs));
			break;
		case 2:
			ret = sensor_write_array(sd, sensor_ev_pos2_regs, ARRAY_SIZE(sensor_ev_pos2_regs));
			break;
		case 3:
			ret = sensor_write_array(sd, sensor_ev_pos3_regs, ARRAY_SIZE(sensor_ev_pos3_regs));
			break;
		case 4:
			ret = sensor_write_array(sd, sensor_ev_pos4_regs, ARRAY_SIZE(sensor_ev_pos4_regs));
			break;
		default:
			return -EINVAL;
	}

	if (ret < 0) {
		vfe_dev_err("sensor_write_array err at sensor_s_exp!\n");
		return ret;
	}
	mdelay(10);
	info->exp = value;
	return 0;
}

static int sensor_g_autoexp(struct v4l2_subdev *sd, __s32 *value)
{
	return 0;
}

static int sensor_s_autoexp(struct v4l2_subdev *sd,
		enum v4l2_exposure_auto_type value)
{
	return 0;
}

static int sensor_g_autowb(struct v4l2_subdev *sd, int *value)
{
	struct sensor_info *info = to_state(sd);
	data_type rdval;

	LOG_ERR_RET(sensor_read(sd, 0x01a0, &rdval))

	rdval &= 0x01;
	rdval = rdval>>1;   //0x3406 bit0 is awb enable

	*value = (rdval == 1)?0:1;
	info->autowb = *value;
	return 0;
}

static int sensor_g_hue(struct v4l2_subdev *sd, __s32 *value)
{
	return -EINVAL;
}

static int sensor_s_hue(struct v4l2_subdev *sd, int value)
{
	return -EINVAL;
}

static int sensor_g_gain(struct v4l2_subdev *sd, __s32 *value)
{
	return -EINVAL;
}

static int sensor_s_gain(struct v4l2_subdev *sd, int value)
{
	return -EINVAL;
}

static int sensor_g_band_filter(struct v4l2_subdev *sd,
    __s32 *value)
{
	struct sensor_info *info = to_state(sd);
	data_type rdval;

	vfe_dev_dbg("%s\n",__func__);
	LOG_ERR_RET(sensor_read(sd, 0x0190, &rdval))

	if(rdval == 0x00)
		info->band_filter = V4L2_CID_POWER_LINE_FREQUENCY_DISABLED;
	else {
		LOG_ERR_RET(sensor_read(sd, 0x019d, &rdval))
		if(rdval == 0x20)
			info->band_filter = V4L2_CID_POWER_LINE_FREQUENCY_50HZ;
		else
			info->band_filter = V4L2_CID_POWER_LINE_FREQUENCY_60HZ;
	}
	return 0;

}

static int sensor_s_band_filter(struct v4l2_subdev *sd,
    enum v4l2_power_line_frequency value)
{
	struct sensor_info *info = to_state(sd);
	data_type rdval;

	vfe_dev_dbg("%s\n",__func__);
	if(info->band_filter == value)
		return 0;

	switch(value) {
		case V4L2_CID_POWER_LINE_FREQUENCY_DISABLED:
			LOG_ERR_RET(sensor_read(sd,0x0190,&rdval))
			LOG_ERR_RET(sensor_write(sd,0x0190,0x00))//turn off band filter
			break;
		case V4L2_CID_POWER_LINE_FREQUENCY_50HZ:
			LOG_ERR_RET(sensor_write(sd,0x019c,0x4b))//50hz
			LOG_ERR_RET(sensor_write(sd,0x019d,0x20))//manual band filter
			LOG_ERR_RET(sensor_read(sd,0x0190,&rdval))
			LOG_ERR_RET(sensor_write(sd,0x0190,0x00))//turn on band filter
			break;
		case V4L2_CID_POWER_LINE_FREQUENCY_60HZ:
			LOG_ERR_RET(sensor_write(sd,0x019c,0x4b))//60hz
			LOG_ERR_RET(sensor_write(sd,0x019d,0xc0))//manual band filter
			LOG_ERR_RET(sensor_read(sd,0x0190,&rdval))
			LOG_ERR_RET(sensor_write(sd,0x0190,0x00))//turn on band filter
			break;
		case V4L2_CID_POWER_LINE_FREQUENCY_AUTO:
			break;
		default:
			break;
	}
	mdelay(10);
	info->band_filter = value;
	return 0;
}




/* stuff about auto focus */


/* *********************************************end of ******************************************** */

static int sensor_g_brightness(struct v4l2_subdev *sd, __s32 *value)
{
	struct sensor_info *info = to_state(sd);

	*value = info->brightness;
	return 0;
}

static int sensor_s_brightness(struct v4l2_subdev *sd, int value)
{
	int ret;
	struct sensor_info *info = to_state(sd);

	switch (value) {
		case -4:
		  ret = sensor_write_array(sd, sensor_brightness_neg4_regs, ARRAY_SIZE(sensor_brightness_neg4_regs));
			break;
		case -3:
			ret = sensor_write_array(sd, sensor_brightness_neg3_regs, ARRAY_SIZE(sensor_brightness_neg3_regs));
			break;
		case -2:
			ret = sensor_write_array(sd, sensor_brightness_neg2_regs, ARRAY_SIZE(sensor_brightness_neg2_regs));
			break;
		case -1:
			ret = sensor_write_array(sd, sensor_brightness_neg1_regs, ARRAY_SIZE(sensor_brightness_neg1_regs));
			break;
		case 0:
			ret = sensor_write_array(sd, sensor_brightness_zero_regs, ARRAY_SIZE(sensor_brightness_zero_regs));
			break;
		case 1:
			ret = sensor_write_array(sd, sensor_brightness_pos1_regs, ARRAY_SIZE(sensor_brightness_pos1_regs));
			break;
		case 2:
			ret = sensor_write_array(sd, sensor_brightness_pos2_regs, ARRAY_SIZE(sensor_brightness_pos2_regs));
			break;
		case 3:
			ret = sensor_write_array(sd, sensor_brightness_pos3_regs, ARRAY_SIZE(sensor_brightness_pos3_regs));
			break;
		case 4:
			ret = sensor_write_array(sd, sensor_brightness_pos4_regs, ARRAY_SIZE(sensor_brightness_pos4_regs));
			break;
		default:
			return -EINVAL;
	}

	if (ret < 0) {
		 vfe_dev_err("sensor_write_array err at sensor_s_brightness!\n");
		return ret;
	}
	mdelay(10);
	info->brightness = value;
	return 0;
}


static int sensor_g_contrast(struct v4l2_subdev *sd, __s32 *value)
{
	struct sensor_info *info = to_state(sd);

	*value = info->contrast;
	return 0;
}

static int sensor_s_contrast(struct v4l2_subdev *sd, int value)
{
	int ret;
	struct sensor_info *info = to_state(sd);

	switch (value) {
		case -4:
		  ret = sensor_write_array(sd, sensor_contrast_neg4_regs, ARRAY_SIZE(sensor_contrast_neg4_regs));
			break;
		case -3:
			ret = sensor_write_array(sd, sensor_contrast_neg3_regs, ARRAY_SIZE(sensor_contrast_neg3_regs));
			break;
		case -2:
			ret = sensor_write_array(sd, sensor_contrast_neg2_regs, ARRAY_SIZE(sensor_contrast_neg2_regs));
			break;
		case -1:
			ret = sensor_write_array(sd, sensor_contrast_neg1_regs, ARRAY_SIZE(sensor_contrast_neg1_regs));
			break;
		case 0:
			ret = sensor_write_array(sd, sensor_contrast_zero_regs, ARRAY_SIZE(sensor_contrast_zero_regs));
			break;
		case 1:
			ret = sensor_write_array(sd, sensor_contrast_pos1_regs, ARRAY_SIZE(sensor_contrast_pos1_regs));
			break;
		case 2:
			ret = sensor_write_array(sd, sensor_contrast_pos2_regs, ARRAY_SIZE(sensor_contrast_pos2_regs));
			break;
		case 3:
			ret = sensor_write_array(sd, sensor_contrast_pos3_regs, ARRAY_SIZE(sensor_contrast_pos3_regs));
			break;
		case 4:
			ret = sensor_write_array(sd, sensor_contrast_pos4_regs, ARRAY_SIZE(sensor_contrast_pos4_regs));
			break;
		default:
			return -EINVAL;
	}

	if (ret < 0) {
		vfe_dev_err("sensor_write_array err at sensor_s_contrast!\n");
		return ret;
	}
	mdelay(10);
	info->contrast = value;
	return 0;
}

static int sensor_g_saturation(struct v4l2_subdev *sd, __s32 *value)
{
	struct sensor_info *info = to_state(sd);

	*value = info->saturation;
	return 0;
}

static int sensor_s_saturation(struct v4l2_subdev *sd, int value)
{
	int ret;
	struct sensor_info *info = to_state(sd);

	switch (value) {
		case -4:
		  ret = sensor_write_array(sd, sensor_saturation_neg4_regs, ARRAY_SIZE(sensor_saturation_neg4_regs));
			break;
		case -3:
			ret = sensor_write_array(sd, sensor_saturation_neg3_regs, ARRAY_SIZE(sensor_saturation_neg3_regs));
			break;
		case -2:
			ret = sensor_write_array(sd, sensor_saturation_neg2_regs, ARRAY_SIZE(sensor_saturation_neg2_regs));
			break;
		case -1:
			ret = sensor_write_array(sd, sensor_saturation_neg1_regs, ARRAY_SIZE(sensor_saturation_neg1_regs));
			break;
		case 0:
			ret = sensor_write_array(sd, sensor_saturation_zero_regs, ARRAY_SIZE(sensor_saturation_zero_regs));
			break;
		case 1:
			ret = sensor_write_array(sd, sensor_saturation_pos1_regs, ARRAY_SIZE(sensor_saturation_pos1_regs));
			break;
		case 2:
			ret = sensor_write_array(sd, sensor_saturation_pos2_regs, ARRAY_SIZE(sensor_saturation_pos2_regs));
			break;
		case 3:
			ret = sensor_write_array(sd, sensor_saturation_pos3_regs, ARRAY_SIZE(sensor_saturation_pos3_regs));
			break;
		case 4:
			ret = sensor_write_array(sd, sensor_saturation_pos4_regs, ARRAY_SIZE(sensor_saturation_pos4_regs));
			break;
		default:
			return -EINVAL;
	}

	if (ret < 0) {
		vfe_dev_err("sensor_write_array err at sensor_s_saturation!\n");
		return ret;
	}
	mdelay(10);
	info->saturation = value;
	return 0;
}

static int sensor_g_wb(struct v4l2_subdev *sd, int *value)
{
	struct sensor_info *info = to_state(sd);
	enum v4l2_auto_n_preset_white_balance *wb_type = (enum v4l2_auto_n_preset_white_balance*)value;

	*wb_type = info->wb;

	return 0;
}
static int sensor_s_autowb(struct v4l2_subdev *sd, int value)
{
	int ret;
	struct sensor_info *info = to_state(sd);

	ret = sensor_write_array(sd, sensor_wb_auto_regs, ARRAY_SIZE(sensor_wb_auto_regs));
	if (ret < 0) {
		vfe_dev_err("sensor_write_array err at sensor_s_autowb!\n");
		return ret;
	}
	mdelay(10);
	info->autowb = value;

	return 0;
}


static int sensor_s_wb(struct v4l2_subdev *sd,
    enum v4l2_auto_n_preset_white_balance value)
{
	int ret;
	struct sensor_info *info = to_state(sd);
	switch (value) {
		case V4L2_WHITE_BALANCE_AUTO:
		  	LOG_ERR_RET(sensor_write_array(sd, sensor_wb_auto_regs ,ARRAY_SIZE(sensor_wb_auto_regs)))
			break;
		case V4L2_WHITE_BALANCE_CLOUDY:
		  	ret = sensor_write_array(sd, sensor_wb_cloud_regs, ARRAY_SIZE(sensor_wb_cloud_regs));
			break;
		case V4L2_WHITE_BALANCE_DAYLIGHT:
			ret = sensor_write_array(sd, sensor_wb_daylight_regs, ARRAY_SIZE(sensor_wb_daylight_regs));
			break;
		case V4L2_WHITE_BALANCE_INCANDESCENT:
			ret = sensor_write_array(sd, sensor_wb_incandescence_regs, ARRAY_SIZE(sensor_wb_incandescence_regs));
			break;
		case V4L2_WHITE_BALANCE_FLUORESCENT_H:
			ret = sensor_write_array(sd, sensor_wb_fluorescent_regs, ARRAY_SIZE(sensor_wb_fluorescent_regs));
			break;
		//case V4L2_WB_TUNGSTEN:
		//	ret = sensor_write_array(sd, sensor_wb_tungsten_regs, ARRAY_SIZE(sensor_wb_tungsten_regs));
		//	break;
		default:
			return -EINVAL;
	}

	if (ret < 0) {
		 vfe_dev_err("sensor_s_wb error, return %x!\n",ret);
		return ret;
	}

	mdelay(10);
	info->wb = value;
	return 0;
}

static int sensor_g_colorfx(struct v4l2_subdev *sd,
    __s32 *value)
{
	struct sensor_info *info = to_state(sd);
	enum v4l2_colorfx *clrfx_type = (enum v4l2_colorfx*)value;

	*clrfx_type = info->clrfx;
	return 0;
}

static int sensor_s_colorfx(struct v4l2_subdev *sd,
    enum v4l2_colorfx value)
{
	int ret;
	struct sensor_info *info = to_state(sd);

	switch (value) {
	case V4L2_COLORFX_NONE:
	  ret = sensor_write_array(sd, sensor_colorfx_none_regs, ARRAY_SIZE(sensor_colorfx_none_regs));
		break;
	case V4L2_COLORFX_BW:
		ret = sensor_write_array(sd, sensor_colorfx_bw_regs, ARRAY_SIZE(sensor_colorfx_bw_regs));
		break;
	case V4L2_COLORFX_SEPIA:
		ret = sensor_write_array(sd, sensor_colorfx_sepia_regs, ARRAY_SIZE(sensor_colorfx_sepia_regs));
		break;
	case V4L2_COLORFX_NEGATIVE:
		ret = sensor_write_array(sd, sensor_colorfx_negative_regs, ARRAY_SIZE(sensor_colorfx_negative_regs));
		break;
	case V4L2_COLORFX_EMBOSS:
		ret = sensor_write_array(sd, sensor_colorfx_emboss_regs, ARRAY_SIZE(sensor_colorfx_emboss_regs));
		break;
	case V4L2_COLORFX_SKETCH:
		ret = sensor_write_array(sd, sensor_colorfx_sketch_regs, ARRAY_SIZE(sensor_colorfx_sketch_regs));
		break;
	case V4L2_COLORFX_SKY_BLUE:
		ret = sensor_write_array(sd, sensor_colorfx_sky_blue_regs, ARRAY_SIZE(sensor_colorfx_sky_blue_regs));
		break;
	case V4L2_COLORFX_GRASS_GREEN:
		ret = sensor_write_array(sd, sensor_colorfx_grass_green_regs, ARRAY_SIZE(sensor_colorfx_grass_green_regs));
		break;
	case V4L2_COLORFX_SKIN_WHITEN:
		ret = sensor_write_array(sd, sensor_colorfx_skin_whiten_regs, ARRAY_SIZE(sensor_colorfx_skin_whiten_regs));
		break;
	case V4L2_COLORFX_VIVID:
		ret = sensor_write_array(sd, sensor_colorfx_vivid_regs, ARRAY_SIZE(sensor_colorfx_vivid_regs));
		break;
	default:
		return -EINVAL;
	}

	if (ret < 0) {
		 vfe_dev_err("sensor_s_colorfx error, return %x!\n",ret);
		return ret;
	}
	info->clrfx = value;
	return 0;
}

/*
 * Stuff that knows about the sensor.
 */
static int sensor_power(struct v4l2_subdev *sd, int on)
{
	switch(on)
	{
		case CSI_SUBDEV_STBY_ON:
			vfe_dev_dbg("CSI_SUBDEV_STBY_ON!\n");
			vfe_dev_print("disalbe oe!\n");
			cci_lock(sd);
			vfe_gpio_write(sd,PWDN,CSI_GPIO_HIGH);
			cci_unlock(sd);
			vfe_set_mclk(sd,OFF);
			break;
		case CSI_SUBDEV_STBY_OFF:
			vfe_dev_dbg("CSI_SUBDEV_STBY_OFF!\n");
			cci_lock(sd);
			vfe_set_mclk_freq(sd,MCLK);
			vfe_set_mclk(sd,ON);
			usleep_range(10000,12000);
			vfe_gpio_write(sd,PWDN,CSI_GPIO_LOW);
			usleep_range(10000,12000);
			vfe_gpio_write(sd,RESET,CSI_GPIO_HIGH);
			usleep_range(10000,12000);
			vfe_gpio_write(sd,RESET,CSI_GPIO_LOW);
			usleep_range(10000,12000);
			vfe_gpio_write(sd,RESET,CSI_GPIO_HIGH);
			usleep_range(10000,12000);
			cci_unlock(sd);
			break;
		case CSI_SUBDEV_PWR_ON:
			vfe_dev_dbg("CSI_SUBDEV_PWR_ON!\n");
			cci_lock(sd);
			// vfe_gpio_set_status(sd,PWDN,1);//set the gpio to output
			// vfe_gpio_set_status(sd,RESET,1);//set the gpio to output
			vfe_gpio_write(sd,PWDN,CSI_GPIO_HIGH);
			vfe_gpio_write(sd,RESET,CSI_GPIO_LOW);
			usleep_range(1000,1200);
			vfe_set_mclk_freq(sd,MCLK);
			vfe_set_mclk(sd,ON);
			usleep_range(10000,12000);
			vfe_gpio_write(sd,POWER_EN,CSI_GPIO_HIGH);
			vfe_set_pmu_channel(sd,IOVDD,ON);
			vfe_set_pmu_channel(sd,AVDD,ON);
			vfe_set_pmu_channel(sd,DVDD,ON);
			vfe_set_pmu_channel(sd,AFVDD,ON);
			vfe_gpio_write(sd,PWDN,CSI_GPIO_LOW);
			usleep_range(10000,12000);
			vfe_gpio_write(sd,RESET,CSI_GPIO_HIGH);
			usleep_range(30000,31000);
			cci_unlock(sd);
			break;
		case CSI_SUBDEV_PWR_OFF:
			vfe_dev_dbg("CSI_SUBDEV_PWR_OFF!\n");
			cci_lock(sd);
			vfe_set_mclk(sd,OFF);
			vfe_gpio_write(sd,POWER_EN,CSI_GPIO_LOW);
			vfe_set_pmu_channel(sd,AFVDD,OFF);
			vfe_set_pmu_channel(sd,DVDD,OFF);
			vfe_set_pmu_channel(sd,AVDD,OFF);
			vfe_set_pmu_channel(sd,IOVDD,OFF);
			usleep_range(10000,12000);
			vfe_gpio_write(sd,PWDN,CSI_GPIO_LOW);
			vfe_gpio_write(sd,RESET,CSI_GPIO_LOW);
			//  vfe_gpio_set_status(sd,RESET,0);//set the gpio to input
			//  vfe_gpio_set_status(sd,PWDN,0);//set the gpio to input
			cci_unlock(sd);
			break;
		default:
			return -EINVAL;
	}

	return 0;
}

static int sensor_reset(struct v4l2_subdev *sd, u32 val)
{
	switch(val)
	{
		case 0:
			vfe_gpio_write(sd,RESET,CSI_GPIO_HIGH);
			mdelay(10);
			break;
		case 1:
			vfe_gpio_write(sd,RESET,CSI_GPIO_LOW);
			mdelay(10);
			break;
		default:
			return -EINVAL;
	}

	return 0;
}

static int sensor_detect(struct v4l2_subdev *sd)
{
	data_type rdval;

	LOG_ERR_RET(sensor_read(sd, 0x0000, &rdval))

	if(rdval != 0x03)
		return -ENODEV;


	return 0;
}

static int sensor_init(struct v4l2_subdev *sd, u32 val)
{
	int ret;
	struct sensor_info *info = to_state(sd);

	vfe_dev_dbg("sensor_init 0x%x\n",val);

	/*Make sure it is a target sensor*/
	ret = sensor_detect(sd);
	if (ret) {
		vfe_dev_err("chip found is not an target chip.\n");
		return ret;
	}

	vfe_get_standby_mode(sd,&info->stby_mode);

	if((info->stby_mode == HW_STBY || info->stby_mode == SW_STBY) \
	  && info->init_first_flag == 0) {
		vfe_dev_print("stby_mode and init_first_flag = 0\n");
		return 0;
	}

	info->focus_status = 0;
	info->low_speed = 0;
	info->width = 0;
	info->height = 0;
	info->brightness = 0;
	info->contrast = 0;
	info->saturation = 0;
	info->hue = 0;
	info->hflip = 0;
	info->vflip = 0;
	info->gain = 0;
	info->autogain = 1;
	info->exp_bias = 0;
	info->autoexp = 0;
	info->autowb = 1;
	info->clrfx = V4L2_COLORFX_NONE;
	info->band_filter = V4L2_CID_POWER_LINE_FREQUENCY_50HZ;

	info->tpf.numerator = 1;
	info->tpf.denominator = 30;    /* 30fps */

	ret = sensor_write_array(sd, sensor_default_regs, ARRAY_SIZE(sensor_default_regs));
	if(ret < 0) {
		vfe_dev_err("write sensor_default_regs error\n");
		return ret;
	}

	sensor_s_band_filter(sd, V4L2_CID_POWER_LINE_FREQUENCY_50HZ);

	if(info->stby_mode == 0)
		info->init_first_flag = 0;

	info->preview_first_flag = 1;

	return 0;
}

static void sensor_s_af_win(struct v4l2_subdev *sd, struct v4l2_win_setting * af_win)
{
	//sensor_s_af_zone(sd, &af_win->coor[0]);
}
static void sensor_s_ae_win(struct v4l2_subdev *sd, struct v4l2_win_setting * ae_win)
{

}

static long sensor_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
{
	int ret=0;
	switch(cmd) {
		case SET_AUTO_FOCUS_WIN:
			sensor_s_af_win(sd, (struct v4l2_win_setting *)arg);
			break;
		case SET_AUTO_EXPOSURE_WIN:
			sensor_s_ae_win(sd, (struct v4l2_win_setting *)arg);
			break;
		default:
			return -EINVAL;
	}
	return ret;
}


/*
 * Store information about the video data format.
 */
static struct sensor_format_struct {
	__u8 *desc;
	//__u32 pixelformat;
	enum v4l2_mbus_pixelcode mbus_code;//linux-3.0
	struct regval_list *regs;
	int	regs_size;
	int bpp;   /* Bytes per pixel */
} sensor_formats[] = {
	{
		.desc		= "YUYV 4:2:2",
		.mbus_code	= V4L2_MBUS_FMT_YUYV8_2X8,//linux-3.0
		.regs 		= sensor_fmt_yuv422_yuyv,
		.regs_size = ARRAY_SIZE(sensor_fmt_yuv422_yuyv),
		.bpp		= 2,
	},
	{
		.desc		= "YVYU 4:2:2",
		.mbus_code	= V4L2_MBUS_FMT_YVYU8_2X8,//linux-3.0
		.regs 		= sensor_fmt_yuv422_yvyu,
		.regs_size = ARRAY_SIZE(sensor_fmt_yuv422_yvyu),
		.bpp		= 2,
	},
	{
		.desc		= "UYVY 4:2:2",
		.mbus_code	= V4L2_MBUS_FMT_UYVY8_2X8,//linux-3.0
		.regs 		= sensor_fmt_yuv422_uyvy,
		.regs_size = ARRAY_SIZE(sensor_fmt_yuv422_uyvy),
		.bpp		= 2,
	},
	{
		.desc		= "VYUY 4:2:2",
		.mbus_code	= V4L2_MBUS_FMT_VYUY8_2X8,//linux-3.0
		.regs 		= sensor_fmt_yuv422_vyuy,
		.regs_size = ARRAY_SIZE(sensor_fmt_yuv422_vyuy),
		.bpp		= 2,
	},
//  {
//    .desc   = "Raw RGB Bayer",
//    .mbus_code  = V4L2_MBUS_FMT_SBGGR8_1X8,
//    .regs     = sensor_fmt_raw,
//    .regs_size = ARRAY_SIZE(sensor_fmt_raw),
//    .bpp    = 1
//  },
};
#define N_FMTS ARRAY_SIZE(sensor_formats)



/*
 * Then there is the issue of window sizes.  Try to capture the info here.
 */


static struct sensor_win_size sensor_win_sizes[] = {
	/* qsxga: 2592*1936 */
	{
		.width      = QSXGA_WIDTH,
		.height     = QSXGA_HEIGHT,
		.hoffset    = 0,
		.voffset    = 0,
		.regs       = sensor_qsxga_regs,
		.regs_size  = ARRAY_SIZE(sensor_qsxga_regs),
		.set_size   = NULL,
	},
	/* qxga: 2048*1536 */
	{
		.width      = QXGA_WIDTH,
		.height     = QXGA_HEIGHT,
		.hoffset    = 0,
		.voffset    = 0,
		.regs       = sensor_qxga_regs,
		.regs_size  = ARRAY_SIZE(sensor_qxga_regs),
		.set_size   = NULL,
	},
	/* 1080P */
	{
		.width      = HD1080_WIDTH,
		.height     = HD1080_HEIGHT,
		.hoffset    = 0,
		.voffset    = 0,
		.regs       = sensor_1080p_regs,
		.regs_size  = ARRAY_SIZE(sensor_1080p_regs),
		.set_size   = NULL,
	},
	/* UXGA */
	{
		.width      = UXGA_WIDTH,
		.height     = UXGA_HEIGHT,
		.hoffset    = 0,
		.voffset    = 0,
		.regs       = sensor_uxga_regs,
		.regs_size  = ARRAY_SIZE(sensor_uxga_regs),
		.set_size   = NULL,
	},
	/* SXGA */
	{
		.width      = SXGA_WIDTH,
		.height     = SXGA_HEIGHT,
		.hoffset    = 0,
		.voffset    = 0,
		.regs       = sensor_sxga_regs,
		.regs_size  = ARRAY_SIZE(sensor_sxga_regs),
		.set_size   = NULL,
	},
	/* 720p */
	{
		.width      = HD720_WIDTH,
		.height     = HD720_HEIGHT,
		.hoffset    = 0,
		.voffset    = 0,
		.regs       = sensor_720p_regs,
		.regs_size  = ARRAY_SIZE(sensor_720p_regs),
		.set_size   = NULL,
	},
	/* XGA */
	{
		.width      = XGA_WIDTH,
		.height     = XGA_HEIGHT,
		.hoffset    = 0,
		.voffset    = 0,
		.regs       = sensor_xga_regs,
		.regs_size  = ARRAY_SIZE(sensor_xga_regs),
		.set_size   = NULL,
	},
	/* SVGA */
	{
		.width      = SVGA_WIDTH,
		.height     = SVGA_HEIGHT,
		.hoffset    = 0,
		.voffset    = 0,
		.regs       = sensor_svga_regs,
		.regs_size  = ARRAY_SIZE(sensor_svga_regs),
		.set_size   = NULL,
	},
	/* VGA */
	{
		.width      = VGA_WIDTH,
		.height     = VGA_HEIGHT,
		.hoffset    = 0,
		.voffset    = 0,
		.regs       = sensor_vga_regs,
		.regs_size  = ARRAY_SIZE(sensor_vga_regs),
		.set_size   = NULL,
	},
};

#define N_WIN_SIZES (ARRAY_SIZE(sensor_win_sizes))

static int sensor_enum_fmt(struct v4l2_subdev *sd, unsigned index,
                 enum v4l2_mbus_pixelcode *code)
{
	if (index >= N_FMTS)
		return -EINVAL;

	*code = sensor_formats[index].mbus_code;
	return 0;
}

static int sensor_enum_size(struct v4l2_subdev *sd,
                            struct v4l2_frmsizeenum *fsize)
{
	if(fsize->index > N_WIN_SIZES-1)
		return -EINVAL;

	fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
	fsize->discrete.width = sensor_win_sizes[fsize->index].width;
	fsize->discrete.height = sensor_win_sizes[fsize->index].height;

	return 0;
}


static int sensor_try_fmt_internal(struct v4l2_subdev *sd,
    struct v4l2_mbus_framefmt *fmt,
    struct sensor_format_struct **ret_fmt,
    struct sensor_win_size **ret_wsize)
{
	int index;
	struct sensor_win_size *wsize;

	for (index = 0; index < N_FMTS; index++)
		if (sensor_formats[index].mbus_code == fmt->code)
			break;

	if (index >= N_FMTS)
		return -EINVAL;

	if (ret_fmt != NULL)
		*ret_fmt = sensor_formats + index;

	/*
	* Fields: the sensor devices claim to be progressive.
	*/
	fmt->field = V4L2_FIELD_NONE;

	/*
	* Round requested image size down to the nearest
	* we support, but not below the smallest.
	*/
	for (wsize = sensor_win_sizes; wsize < sensor_win_sizes + N_WIN_SIZES; wsize++)
		if (fmt->width >= wsize->width && fmt->height >= wsize->height)
			break;

	if (wsize >= sensor_win_sizes + N_WIN_SIZES)
		wsize--;   /* Take the smallest one */
	if (ret_wsize != NULL)
		*ret_wsize = wsize;
	/*
	* Note the size we'll actually handle.
	*/
	fmt->width = wsize->width;
	fmt->height = wsize->height;

	return 0;
}

static int sensor_try_fmt(struct v4l2_subdev *sd,
             struct v4l2_mbus_framefmt *fmt)
{
	return sensor_try_fmt_internal(sd, fmt, NULL, NULL);
}

static int sensor_g_mbus_config(struct v4l2_subdev *sd,
           struct v4l2_mbus_config *cfg)
{
	cfg->type = V4L2_MBUS_PARALLEL;
	cfg->flags = V4L2_MBUS_MASTER | VREF_POL | HREF_POL | CLK_POL ;

	return 0;
}

/*
 * Set a format.
 */
static int sensor_s_fmt(struct v4l2_subdev *sd,
             struct v4l2_mbus_framefmt *fmt)//linux-3.0
{
	int ret;
	struct sensor_format_struct *sensor_fmt;
	struct sensor_win_size *wsize;
	struct sensor_info *info = to_state(sd);
	int cnt;
	data_type retval,pos_l=0,pos_h=0;

	vfe_dev_print(" sensor_s_fmt\n");

	ret = sensor_try_fmt_internal(sd, fmt, &sensor_fmt, &wsize);
	if (ret)
		return ret;
	if(info->capture_mode == V4L2_MODE_IMAGE)
	{
		LOG_ERR_RET(sensor_write(sd, 0x070B, 0x01))
		LOG_ERR_RET(sensor_write(sd, 0x070A, 0x03))
		mdelay(200);
		LOG_ERR_RET(sensor_write(sd, 0x070B, 0x02))
		for(cnt=0;cnt<20;cnt++)
		{
	  		LOG_ERR_RET(sensor_read(sd, 0x07AE, &retval))
			if(retval==1)
				break;
		}
		 LOG_ERR_RET(sensor_read(sd, 0x06F0, &pos_h))
		 LOG_ERR_RET(sensor_read(sd, 0x06F1, &pos_l))


	}
	else if(info->capture_mode == V4L2_MODE_PREVIEW)
		sensor_s_continueous_af(sd);

	sensor_write_array(sd, sensor_fmt->regs , sensor_fmt->regs_size);//add by xiongbiao on 20130403
	ret = 0;
	if (wsize->regs)
	{
		ret = sensor_write_array(sd, wsize->regs , wsize->regs_size);
		if (ret < 0)
			return ret;
	}
	if(info->capture_mode == V4L2_MODE_VIDEO)
	{
  		LOG_ERR_RET(sensor_write(sd, 0x070A, 0x00))

		 vfe_dev_print("info->capture_mode == V4L2_MODE_VIDEO\n");
	}
	else if(info->capture_mode == V4L2_MODE_IMAGE)
	{
		vfe_dev_print("info->capture_mode == V4L2_MODE_IMAGE\n");
		LOG_ERR_RET(sensor_write(sd, 0x070A, 0x00))
		LOG_ERR_RET(sensor_write(sd, 0x0734, pos_h))
		LOG_ERR_RET(sensor_write(sd, 0x0735, pos_l))
		LOG_ERR_RET(sensor_write(sd, 0x070c, 0x00))
		mdelay(200);
		LOG_ERR_RET(sensor_write(sd, 0x070c, 0x05))
		mdelay(200);

	}
	if (wsize->set_size)
	{
		ret = wsize->set_size(sd);
		if (ret < 0)
			return ret;
	}
	info->fmt = sensor_fmt;
	info->width = wsize->width;
	info->height = wsize->height;
	vfe_dev_print("s_fmt=%s set width = %d, height = %d\n",sensor_fmt->desc,wsize->width,wsize->height);

	return 0;
}


/*
 * Implement G/S_PARM.  There is a "high quality" mode we could try
 * to do someday; for now, we just do the frame rate tweak.
 */
static int sensor_g_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *parms)
{
	struct v4l2_captureparm *cp = &parms->parm.capture;
	struct sensor_info *info = to_state(sd);

	if (parms->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
		return -EINVAL;

	memset(cp, 0, sizeof(struct v4l2_captureparm));
	cp->capability = V4L2_CAP_TIMEPERFRAME;
	cp->capturemode = info->capture_mode;

	cp->timeperframe.numerator = info->tpf.numerator;
	cp->timeperframe.denominator = info->tpf.denominator;

	return 0;
}

static int sensor_s_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *parms)
{
	struct v4l2_captureparm *cp = &parms->parm.capture;
	struct v4l2_fract *tpf = &cp->timeperframe;
	struct sensor_info *info = to_state(sd);
	data_type div;

	vfe_dev_dbg("sensor_s_parm\n");

	if (parms->type != V4L2_BUF_TYPE_VIDEO_CAPTURE){
		vfe_dev_dbg("parms->type!=V4L2_BUF_TYPE_VIDEO_CAPTURE\n");
		return -EINVAL;
	}

	if (info->tpf.numerator == 0){
		vfe_dev_dbg("info->tpf.numerator == 0\n");
		return -EINVAL;
	}

	info->capture_mode = cp->capturemode;

	if (info->capture_mode == V4L2_MODE_IMAGE) {
		vfe_dev_dbg("capture mode is not video mode,can not set frame rate!\n");
		return 0;
	}

	if (tpf->numerator == 0 || tpf->denominator == 0) {
		tpf->numerator = 1;
		tpf->denominator = SENSOR_FRAME_RATE;/* Reset to full rate */
		vfe_dev_err("sensor frame rate reset to full rate!\n");
	}

	div = SENSOR_FRAME_RATE/(tpf->denominator/tpf->numerator);
	if(div > 15 || div == 0)
	{
		vfe_dev_print("SENSOR_FRAME_RATE=%d\n",SENSOR_FRAME_RATE);
		vfe_dev_print("tpf->denominator=%d\n",tpf->denominator);
		vfe_dev_print("tpf->numerator=%d\n",tpf->numerator);
		return -EINVAL;
	}

	vfe_dev_dbg("set frame rate %d\n",tpf->denominator/tpf->numerator);

	info->tpf.denominator = SENSOR_FRAME_RATE;
	info->tpf.numerator = div;

	if(info->tpf.denominator/info->tpf.numerator < 30)
		info->low_speed = 1;

	return 0;
}


/*
 * Code for dealing with controls.
 * fill with different sensor module
 * different sensor module has different settings here
 * if not support the follow function ,retrun -EINVAL
 */

/* *********************************************begin of ******************************************** */
static int sensor_queryctrl(struct v4l2_subdev *sd,
    struct v4l2_queryctrl *qc)
{
	/* Fill in min, max, step and default value for these controls. */
	/* see include/linux/videodev2.h for details */
	/* see sensor_s_parm and sensor_g_parm for the meaning of value */

	switch (qc->id) {
	case V4L2_CID_BRIGHTNESS:
		return v4l2_ctrl_query_fill(qc, -4, 4, 1, 1);
	case V4L2_CID_CONTRAST:
		return v4l2_ctrl_query_fill(qc, -4, 4, 1, 1);
	case V4L2_CID_SATURATION:
		return v4l2_ctrl_query_fill(qc, -4, 4, 1, 1);
	case V4L2_CID_HUE:
		return v4l2_ctrl_query_fill(qc, -180, 180, 5, 0);
	case V4L2_CID_VFLIP:
	case V4L2_CID_HFLIP:
		return v4l2_ctrl_query_fill(qc, 0, 1, 1, 0);
	case V4L2_CID_GAIN:
		return v4l2_ctrl_query_fill(qc, 0, 255, 1, 128);
	case V4L2_CID_AUTOGAIN:
		return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
	case V4L2_CID_EXPOSURE:
	case V4L2_CID_AUTO_EXPOSURE_BIAS:
		return v4l2_ctrl_query_fill(qc, -4, 4, 1, -1);
	case V4L2_CID_EXPOSURE_AUTO:
		return v4l2_ctrl_query_fill(qc, -4, 4, 1, -1);
	case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
		return v4l2_ctrl_query_fill(qc, 0, 9, 1, 1);
	case V4L2_CID_AUTO_WHITE_BALANCE:
		return v4l2_ctrl_query_fill(qc, 0, 9, 1, 1);
	case V4L2_CID_COLORFX:
		return v4l2_ctrl_query_fill(qc, 0, 15, 1, 0);
	case V4L2_CID_FLASH_LED_MODE:
		return v4l2_ctrl_query_fill(qc, 0, 4, 1, 0);
	case V4L2_CID_3A_LOCK:
		return v4l2_ctrl_query_fill(qc, 0, V4L2_LOCK_FOCUS, 1, 0);
//	case V4L2_CID_AUTO_FOCUS_RANGE:
//		return v4l2_ctrl_query_fill(qc, 0, 0, 0, 0);//only auto
	case V4L2_CID_AUTO_FOCUS_INIT:
	case V4L2_CID_AUTO_FOCUS_RELEASE:
	case V4L2_CID_AUTO_FOCUS_START:
	case V4L2_CID_AUTO_FOCUS_STOP:
	case V4L2_CID_AUTO_FOCUS_STATUS:
		return v4l2_ctrl_query_fill(qc, 0, 0, 0, 0);
	case V4L2_CID_FOCUS_AUTO:
		return v4l2_ctrl_query_fill(qc, 0, 1, 1, 0);
	}
	return -EINVAL;
}

static int sensor_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
{
	switch (ctrl->id) {
	case V4L2_CID_BRIGHTNESS:
		return sensor_g_brightness(sd, &ctrl->value);
	case V4L2_CID_CONTRAST:
		return sensor_g_contrast(sd, &ctrl->value);
	case V4L2_CID_SATURATION:
		return sensor_g_saturation(sd, &ctrl->value);
	case V4L2_CID_HUE:
		return sensor_g_hue(sd, &ctrl->value);
	case V4L2_CID_VFLIP:
		return sensor_g_vflip(sd, &ctrl->value);
	case V4L2_CID_HFLIP:
		return sensor_g_hflip(sd, &ctrl->value);
	case V4L2_CID_GAIN:
		return sensor_g_gain(sd, &ctrl->value);
	case V4L2_CID_AUTOGAIN:
		return sensor_g_autogain(sd, &ctrl->value);
	case V4L2_CID_EXPOSURE:
	case V4L2_CID_AUTO_EXPOSURE_BIAS:
		return sensor_g_exp(sd, &ctrl->value);
	case V4L2_CID_EXPOSURE_AUTO:
		return sensor_g_autoexp(sd, &ctrl->value);
	case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
		return sensor_g_wb(sd, &ctrl->value);
	case V4L2_CID_AUTO_WHITE_BALANCE:
		return sensor_g_autowb(sd, &ctrl->value);
	case V4L2_CID_COLORFX:
		return sensor_g_colorfx(sd, &ctrl->value);
//	case V4L2_CID_FLASH_LED_MODE:
//		return sensor_g_flash_mode(sd, &ctrl->value);
	case V4L2_CID_POWER_LINE_FREQUENCY:
		return sensor_g_band_filter(sd, &ctrl->value);
	case V4L2_CID_3A_LOCK:
		return sensor_g_3a_lock(sd);
//	case V4L2_CID_AUTO_FOCUS_RANGE:
//		ctrl->value=0;//only auto
//		return 0;
//	case V4L2_CID_AUTO_FOCUS_INIT:
//	case V4L2_CID_AUTO_FOCUS_RELEASE:
//	case V4L2_CID_AUTO_FOCUS_START:
//	case V4L2_CID_AUTO_FOCUS_STOP:
	case V4L2_CID_AUTO_FOCUS_STATUS:
		return sensor_g_af_status(sd);
//	case V4L2_CID_FOCUS_AUTO:
	}
	return -EINVAL;
}

static int sensor_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
{
	switch (ctrl->id) {
	case V4L2_CID_BRIGHTNESS:
		return sensor_s_brightness(sd, ctrl->value);
	case V4L2_CID_CONTRAST:
		return sensor_s_contrast(sd, ctrl->value);
	case V4L2_CID_SATURATION:
		return sensor_s_saturation(sd, ctrl->value);
	case V4L2_CID_HUE:
		return sensor_s_hue(sd, ctrl->value);
	case V4L2_CID_VFLIP:
		return sensor_s_vflip(sd, ctrl->value);
	case V4L2_CID_HFLIP:
		return sensor_s_hflip(sd, ctrl->value);
	case V4L2_CID_GAIN:
		return sensor_s_gain(sd, ctrl->value);
	case V4L2_CID_AUTOGAIN:
		return sensor_s_autogain(sd, ctrl->value);
	case V4L2_CID_EXPOSURE:
	case V4L2_CID_AUTO_EXPOSURE_BIAS:
		return sensor_s_exp(sd, ctrl->value);
	case V4L2_CID_EXPOSURE_AUTO:
	return sensor_s_autoexp(sd, (enum v4l2_exposure_auto_type) ctrl->value);
	case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
		return sensor_s_wb(sd, (enum v4l2_auto_n_preset_white_balance) ctrl->value);
	case V4L2_CID_AUTO_WHITE_BALANCE:
		return sensor_s_autowb(sd, ctrl->value);
	case V4L2_CID_COLORFX:
		return sensor_s_colorfx(sd, (enum v4l2_colorfx) ctrl->value);
//	case V4L2_CID_FLASH_LED_MODE:
//		return sensor_s_flash_mode(sd, (enum v4l2_flash_led_mode) ctrl->value);
	case V4L2_CID_POWER_LINE_FREQUENCY:
	return sensor_s_band_filter(sd, (enum v4l2_power_line_frequency) ctrl->value);
//	case V4L2_CID_3A_LOCK:
//		return sensor_s_3a_lock(sd, ctrl->value);
//	case V4L2_CID_AUTO_FOCUS_RANGE:
//		return 0;
	case V4L2_CID_AUTO_FOCUS_INIT:
		return sensor_s_init_af(sd);
	case V4L2_CID_AUTO_FOCUS_RELEASE:
		return sensor_s_release_af(sd);
	case V4L2_CID_AUTO_FOCUS_START:
		return sensor_s_single_af(sd);
	case V4L2_CID_AUTO_FOCUS_STOP:
		return sensor_s_pause_af(sd);
	case V4L2_CID_AUTO_FOCUS_STATUS:
	case V4L2_CID_FOCUS_AUTO:
		return sensor_s_continueous_af(sd);
	}
	return -EINVAL;
}


static int sensor_g_chip_ident(struct v4l2_subdev *sd,
    struct v4l2_dbg_chip_ident *chip)
{
	struct i2c_client *client = v4l2_get_subdevdata(sd);

	return v4l2_chip_ident_i2c_client(client, chip, V4L2_IDENT_SENSOR, 0);
}


/* ----------------------------------------------------------------------- */

static const struct v4l2_subdev_core_ops sensor_core_ops = {
	.g_chip_ident = sensor_g_chip_ident,
	.g_ctrl = sensor_g_ctrl,
	.s_ctrl = sensor_s_ctrl,
	.queryctrl = sensor_queryctrl,
	.reset = sensor_reset,
	.init = sensor_init,
	.s_power = sensor_power,
	.ioctl = sensor_ioctl,
};

static const struct v4l2_subdev_video_ops sensor_video_ops = {
	.enum_mbus_fmt = sensor_enum_fmt,
	.enum_framesizes = sensor_enum_size,
	.try_mbus_fmt = sensor_try_fmt,
	.s_mbus_fmt = sensor_s_fmt,
	.s_parm = sensor_s_parm,
	.g_parm = sensor_g_parm,
	.g_mbus_config = sensor_g_mbus_config,
};

static const struct v4l2_subdev_ops sensor_ops = {
	.core = &sensor_core_ops,
	.video = &sensor_video_ops,
};

/* ----------------------------------------------------------------------- */
static struct cci_driver cci_drv = {
	.name = SENSOR_NAME,
	.addr_width = CCI_BITS_16,
	.data_width = CCI_BITS_8,
};


static int sensor_probe(struct i2c_client *client,
      const struct i2c_device_id *id)
{
	struct v4l2_subdev *sd;
	struct sensor_info *info;
	info = kzalloc(sizeof(struct sensor_info), GFP_KERNEL);
	if (info == NULL)
		return -ENOMEM;
	sd = &info->sd;
	glb_sd = sd;
	cci_dev_probe_helper(sd, client, &sensor_ops, &cci_drv);
	info->fmt = &sensor_formats[0];
	info->af_first_flag = 1;
	info->init_first_flag = 1;
	info->auto_focus = 0;
	return 0;
}


static int sensor_remove(struct i2c_client *client)
{
	struct v4l2_subdev *sd;

	sd = cci_dev_remove_helper(client, &cci_drv);
	kfree(to_state(sd));
	return 0;
}

static const struct i2c_device_id sensor_id[] = {
	{ SENSOR_NAME, 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, sensor_id);

static struct i2c_driver sensor_driver = {
	.driver = {
		.owner = THIS_MODULE,
		.name = SENSOR_NAME,
	},
	.probe = sensor_probe,
	.remove = sensor_remove,
	.id_table = sensor_id,
};
static __init int init_sensor(void)
{
	return cci_dev_init_helper(&sensor_driver);
}

static __exit void exit_sensor(void)
{
	cci_dev_exit_helper(&sensor_driver);
}

module_init(init_sensor);
module_exit(exit_sensor);

